CacheControl

org.springframework.http.CacheControl

protected CacheControl CacheControl()

{
}
org.springframework.http.CacheControl

public CacheControl cachePrivate()

{
    this.cachePrivate = true;
    return this;
}
org.springframework.http.CacheControl

public CacheControl cachePublic()

{
    this.cachePublic = true;
    return this;
}
org.springframework.http.CacheControl

public static CacheControl empty()

{
    return new CacheControl();
}
org.springframework.http.CacheControl

@Nullable public String getHeaderValue()

{
    String headerValue = toHeaderValue();
    return (StringUtils.hasText(headerValue) ? headerValue : null);
}
org.springframework.http.CacheControl

public static CacheControl maxAge(long maxAge, TimeUnit unit)

{
    return maxAge(Duration.ofSeconds(unit.toSeconds(maxAge)));
}
org.springframework.http.CacheControl

public static CacheControl maxAge(Duration maxAge)

{
    CacheControl cc = new CacheControl();
    cc.maxAge = maxAge;
    return cc;
}
org.springframework.http.CacheControl

public CacheControl mustRevalidate()

{
    this.mustRevalidate = true;
    return this;
}
org.springframework.http.CacheControl

public static CacheControl noCache()

{
    CacheControl cc = new CacheControl();
    cc.noCache = true;
    return cc;
}
org.springframework.http.CacheControl

public static CacheControl noStore()

{
    CacheControl cc = new CacheControl();
    cc.noStore = true;
    return cc;
}
org.springframework.http.CacheControl

public CacheControl noTransform()

{
    this.noTransform = true;
    return this;
}
org.springframework.http.CacheControl

public CacheControl proxyRevalidate()

{
    this.proxyRevalidate = true;
    return this;
}
org.springframework.http.CacheControl

public CacheControl sMaxAge(long sMaxAge, TimeUnit unit)

{
    return sMaxAge(Duration.ofSeconds(unit.toSeconds(sMaxAge)));
}
org.springframework.http.CacheControl

public CacheControl sMaxAge(Duration sMaxAge)

{
    this.sMaxAge = sMaxAge;
    return this;
}
org.springframework.http.CacheControl

public CacheControl staleIfError(long staleIfError, TimeUnit unit)

{
    return staleIfError(Duration.ofSeconds(unit.toSeconds(staleIfError)));
}
org.springframework.http.CacheControl

public CacheControl staleIfError(Duration staleIfError)

{
    this.staleIfError = staleIfError;
    return this;
}
org.springframework.http.CacheControl

public CacheControl staleWhileRevalidate(long staleWhileRevalidate, TimeUnit unit)

{
    return staleWhileRevalidate(Duration.ofSeconds(unit.toSeconds(staleWhileRevalidate)));
}
org.springframework.http.CacheControl

public CacheControl staleWhileRevalidate(Duration staleWhileRevalidate)

{
    this.staleWhileRevalidate = staleWhileRevalidate;
    return this;
}
org.springframework.http.CacheControl

@Override public String toString()

{
    return "CacheControl [" + toHeaderValue() + "]";
}
ContentDisposition

Builder
org.springframework.http.ContentDisposition

public static Builder builder(String type)

{
    return new BuilderImpl(type);
}
org.springframework.http.ContentDisposition

public static ContentDisposition empty()

{
    return new ContentDisposition("", null, null, null, null, null, null, null);
}
org.springframework.http.ContentDisposition

@Override public boolean equals(@Nullable Object other)

{
    if (this == other) {
        return true;
    } 
    if (!(other instanceof ContentDisposition)) {
        return false;
    } 
    ContentDisposition otherCd = (ContentDisposition)other;
    return (ObjectUtils.nullSafeEquals(this.type, otherCd.type) && ObjectUtils.nullSafeEquals(this.name, otherCd.name) && ObjectUtils.nullSafeEquals(this.filename, otherCd.filename) && ObjectUtils.nullSafeEquals(this.charset, otherCd.charset) && ObjectUtils.nullSafeEquals(this.size, otherCd.size) && ObjectUtils.nullSafeEquals(this.creationDate, otherCd.creationDate) && ObjectUtils.nullSafeEquals(this.modificationDate, otherCd.modificationDate) && ObjectUtils.nullSafeEquals(this.readDate, otherCd.readDate));
}
org.springframework.http.ContentDisposition

@Nullable public Charset getCharset()

{
    return this.charset;
}
org.springframework.http.ContentDisposition

@Nullable public ZonedDateTime getCreationDate()

{
    return this.creationDate;
}
org.springframework.http.ContentDisposition

@Nullable public String getFilename()

{
    return this.filename;
}
org.springframework.http.ContentDisposition

@Nullable public ZonedDateTime getModificationDate()

{
    return this.modificationDate;
}
org.springframework.http.ContentDisposition

@Nullable public String getName()

{
    return this.name;
}
org.springframework.http.ContentDisposition

@Nullable public ZonedDateTime getReadDate()

{
    return this.readDate;
}
org.springframework.http.ContentDisposition

@Nullable public Long getSize()

{
    return this.size;
}
org.springframework.http.ContentDisposition

@Nullable public String getType()

{
    return this.type;
}
org.springframework.http.ContentDisposition

public static ContentDisposition parse(String contentDisposition)

{
    List<String> parts = tokenize(contentDisposition);
    String type = parts.get(0);
    String name = null;
    String filename = null;
    Charset charset = null;
    Long size = null;
    ZonedDateTime creationDate = null;
    ZonedDateTime modificationDate = null;
    ZonedDateTime readDate = null;
    for (int i = 1; i < parts.size(); i++) {
        String part = parts.get(i);
        int eqIndex = part.indexOf('=');
        if (eqIndex != -1) {
            String attribute = part.substring(0, eqIndex);
            String value = (part.startsWith("\"", eqIndex + 1) && part.endsWith("\"") ? part.substring(eqIndex + 2, part.length() - 1) : part.substring(eqIndex + 1));
            if (attribute.equals("name")) {
                name = value;
            } else if (attribute.equals("filename*")) {
                int idx1 = value.indexOf('\'');
                int idx2 = value.indexOf('\'', idx1 + 1);
                if (idx1 != -1 && idx2 != -1) {
                    charset = Charset.forName(value.substring(0, idx1));
                    Assert.isTrue(UTF_8.equals(charset) || ISO_8859_1.equals(charset), "Charset should be UTF-8 or ISO-8859-1");
                    filename = decodeFilename(value.substring(idx2 + 1), charset);
                } else {
                    filename = decodeFilename(value, StandardCharsets.US_ASCII);
                }
            } else if (attribute.equals("filename") && (filename == null)) {
                filename = value;
            } else if (attribute.equals("size")) {
                size = Long.parseLong(value);
            } else if (attribute.equals("creation-date")) {
                try {
                    creationDate = ZonedDateTime.parse(value, RFC_1123_DATE_TIME);
                } catch (DateTimeParseException ex) {
                }
            } else if (attribute.equals("modification-date")) {
                try {
                    modificationDate = ZonedDateTime.parse(value, RFC_1123_DATE_TIME);
                } catch (DateTimeParseException ex) {
                }
            } else if (attribute.equals("read-date")) {
                try {
                    readDate = ZonedDateTime.parse(value, RFC_1123_DATE_TIME);
                } catch (DateTimeParseException ex) {
                }
            } 
        } else {
            throw new IllegalArgumentException("Invalid content disposition format");
        }
    }
    return new ContentDisposition(type, name, filename, charset, size, creationDate, modificationDate, readDate);
}
HttpCookie

org.springframework.http.HttpCookie

public HttpCookie HttpCookie(String name, @Nullable String value)

{
    Assert.hasLength(name, "'name' is required and must not be empty.");
    this.name = name;
    this.value = (value != null ? value : "");
}
org.springframework.http.HttpCookie

@Override public boolean equals(@Nullable Object other)

{
    if (this == other) {
        return true;
    } 
    if (!(other instanceof HttpCookie)) {
        return false;
    } 
    HttpCookie otherCookie = (HttpCookie)other;
    return (this.name.equalsIgnoreCase(otherCookie.getName()));
}
org.springframework.http.HttpCookie

public String getName()

{
    return this.name;
}
org.springframework.http.HttpCookie

public String getValue()

{
    return this.value;
}
org.springframework.http.HttpCookie

@Override public int hashCode()

{
    return this.name.hashCode();
}
org.springframework.http.HttpCookie

@Override public String toString()

{
    return this.name + '=' + this.value;
}
HttpEntity<T>

org.springframework.http.HttpEntity

public static final HttpEntity<?> EMPTY

org.springframework.http.HttpEntity
protected HttpEntity HttpEntity()
{
    this(null, null);
}
org.springframework.http.HttpEntity
public HttpEntity HttpEntity(T body)
{
    this(body, null);
}
org.springframework.http.HttpEntity
public HttpEntity HttpEntity(MultiValueMap<String, String> headers)
{
    this(null, headers);
}
org.springframework.http.HttpEntity
public HttpEntity HttpEntity(@Nullable T body, @Nullable MultiValueMap<String, String> headers)
{
    this.body = body;
    HttpHeaders tempHeaders = new HttpHeaders();
    if (headers != null) {
        tempHeaders.putAll(headers);
    } 
    this.headers = HttpHeaders.readOnlyHttpHeaders(tempHeaders);
}
org.springframework.http.HttpEntity
@Override public boolean equals(@Nullable Object other)
{
    if (this == other) {
        return true;
    } 
    if (other == null || other.getClass() != getClass()) {
        return false;
    } 
    HttpEntity<?> otherEntity = (HttpEntity<?>)other;
    return (ObjectUtils.nullSafeEquals(this.headers, otherEntity.headers) && ObjectUtils.nullSafeEquals(this.body, otherEntity.body));
}
org.springframework.http.HttpEntity
@Nullable public T getBody()
{
    return this.body;
}
org.springframework.http.HttpEntity
public HttpHeaders getHeaders()
{
    return this.headers;
}
org.springframework.http.HttpEntity
public boolean hasBody()
{
    return (this.body != null);
}
org.springframework.http.HttpEntity
@Override public String toString()
{
    StringBuilder builder = new StringBuilder("<");
    if (this.body != null) {
        builder.append(this.body);
        builder.append(',');
    } 
    builder.append(this.headers);
    builder.append('>');
    return builder.toString();
}
 HttpHeaders
 implements MultiValueMap<String, String>, Serializable
org.springframework.http.HttpHeaders
public static final String ACCEPT
org.springframework.http.HttpHeaders
public static final String ACCEPT_CHARSET
org.springframework.http.HttpHeaders
public static final String ACCEPT_ENCODING
org.springframework.http.HttpHeaders
public static final String ACCEPT_LANGUAGE
org.springframework.http.HttpHeaders
public static final String ACCEPT_RANGES
org.springframework.http.HttpHeaders
public static final String ACCESS_CONTROL_ALLOW_CREDENTIALS
org.springframework.http.HttpHeaders
public static final String ACCESS_CONTROL_ALLOW_HEADERS
org.springframework.http.HttpHeaders
public static final String ACCESS_CONTROL_ALLOW_METHODS
org.springframework.http.HttpHeaders
public static final String ACCESS_CONTROL_ALLOW_ORIGIN
org.springframework.http.HttpHeaders
public static final String ACCESS_CONTROL_EXPOSE_HEADERS
org.springframework.http.HttpHeaders
public static final String ACCESS_CONTROL_MAX_AGE
org.springframework.http.HttpHeaders
public static final String ACCESS_CONTROL_REQUEST_HEADERS
org.springframework.http.HttpHeaders
public static final String ACCESS_CONTROL_REQUEST_METHOD
org.springframework.http.HttpHeaders
public static final String AGE
org.springframework.http.HttpHeaders
public static final String ALLOW
org.springframework.http.HttpHeaders
public static final String AUTHORIZATION
org.springframework.http.HttpHeaders
public static final String CACHE_CONTROL
org.springframework.http.HttpHeaders
public static final String CONNECTION
org.springframework.http.HttpHeaders
public static final String CONTENT_DISPOSITION
org.springframework.http.HttpHeaders
public static final String CONTENT_ENCODING
org.springframework.http.HttpHeaders
public static final String CONTENT_LANGUAGE
org.springframework.http.HttpHeaders
public static final String CONTENT_LENGTH
org.springframework.http.HttpHeaders
public static final String CONTENT_LOCATION
org.springframework.http.HttpHeaders
public static final String CONTENT_RANGE
org.springframework.http.HttpHeaders
public static final String CONTENT_TYPE
org.springframework.http.HttpHeaders
public static final String DATE
org.springframework.http.HttpHeaders
public static final HttpHeaders EMPTY
org.springframework.http.HttpHeaders
public static final String ETAG
org.springframework.http.HttpHeaders
public static final String EXPECT
org.springframework.http.HttpHeaders
public static final String EXPIRES
org.springframework.http.HttpHeaders
public static final String FROM
org.springframework.http.HttpHeaders
public static final String HOST
org.springframework.http.HttpHeaders
public HttpHeaders HttpHeaders()
{
    this(CollectionUtils.toMultiValueMap(new LinkedCaseInsensitiveMap<>(8, Locale.ENGLISH)));
}
org.springframework.http.HttpHeaders
public HttpHeaders HttpHeaders(MultiValueMap<String, String> headers)
{
    Assert.notNull(headers, "MultiValueMap must not be null");
    this.headers = headers;
}
org.springframework.http.HttpHeaders
public static final String IF_MATCH
org.springframework.http.HttpHeaders
public static final String IF_MODIFIED_SINCE
org.springframework.http.HttpHeaders
public static final String IF_NONE_MATCH
org.springframework.http.HttpHeaders
public static final String IF_RANGE
org.springframework.http.HttpHeaders
public static final String IF_UNMODIFIED_SINCE
org.springframework.http.HttpHeaders
public static final String LAST_MODIFIED
org.springframework.http.HttpHeaders
public static final String LOCATION
org.springframework.http.HttpHeaders
public static final String MAX_FORWARDS
org.springframework.http.HttpHeaders
public static final String ORIGIN
org.springframework.http.HttpHeaders
public static final String PRAGMA
org.springframework.http.HttpHeaders
public static final String PROXY_AUTHENTICATE
org.springframework.http.HttpHeaders
public static final String PROXY_AUTHORIZATION
org.springframework.http.HttpHeaders
public static final String RANGE
org.springframework.http.HttpHeaders
public static final String REFERER
org.springframework.http.HttpHeaders
public static final String RETRY_AFTER
org.springframework.http.HttpHeaders
public static final String SERVER
org.springframework.http.HttpHeaders
public static final String SET_COOKIE2
org.springframework.http.HttpHeaders
public static final String TE
org.springframework.http.HttpHeaders
public static final String TRAILER
org.springframework.http.HttpHeaders
public static final String TRANSFER_ENCODING
org.springframework.http.HttpHeaders
public static final String UPGRADE
org.springframework.http.HttpHeaders
public static final String USER_AGENT
org.springframework.http.HttpHeaders
public static final String VARY
org.springframework.http.HttpHeaders
public static final String VIA
org.springframework.http.HttpHeaders
public static final String WARNING
org.springframework.http.HttpHeaders
public static final String WWW_AUTHENTICATE
org.springframework.http.HttpHeaders
@Override public void add(String headerName, @Nullable String headerValue)
{
    this.headers.add(headerName, headerValue);
}
org.springframework.http.HttpHeaders
@Override public void addAll(String key, List<?> values)
{
    this.headers.addAll(key, values);
}
org.springframework.http.HttpHeaders
@Override public void addAll(MultiValueMap<String, String> values)
{
    this.headers.addAll(values);
}
org.springframework.http.HttpHeaders
@Override public void clear()
{
    this.headers.clear();
}
org.springframework.http.HttpHeaders
@Override public boolean containsKey(Object key)
{
    return this.headers.containsKey(key);
}
org.springframework.http.HttpHeaders
@Override public boolean containsValue(Object value)
{
    return this.headers.containsValue(value);
}
org.springframework.http.HttpHeaders
public static String encodeBasicAuth(String username, String password, @Nullable Charset charset)
{
    Assert.notNull(username, "Username must not be null");
    Assert.doesNotContain(username, ":", "Username must not contain a colon");
    Assert.notNull(password, "Password must not be null");
    if (charset == null) {
        charset = StandardCharsets.ISO_8859_1;
    } 
    CharsetEncoder encoder = charset.newEncoder();
    if (!encoder.canEncode(username) || !encoder.canEncode(password)) {
        throw new IllegalArgumentException("Username or password contains characters that cannot be encoded to " + charset.displayName());
    } 
    String credentialsString = username + ":" + password;
    byte[] encodedBytes = Base64.getEncoder().encode(credentialsString.getBytes(charset));
    return new String(encodedBytes, charset);
}
org.springframework.http.HttpHeaders
@Override public Set<Entry<String, List<String>>> entrySet()
{
    return this.headers.entrySet();
}
org.springframework.http.HttpHeaders
@Override public boolean equals(@Nullable Object other)
{
    if (this == other) {
        return true;
    } 
    if (!(other instanceof HttpHeaders)) {
        return false;
    } 
    HttpHeaders otherHeaders = (HttpHeaders)other;
    return this.headers.equals(otherHeaders.headers);
}
org.springframework.http.HttpHeaders
@Override @Nullable public List<String> get(Object key)
{
    return this.headers.get(key);
}
org.springframework.http.HttpHeaders
public List<MediaType> getAccept()
{
    return MediaType.parseMediaTypes(get(ACCEPT));
}
org.springframework.http.HttpHeaders
public List<Locale> getAcceptLanguageAsLocales()
{
    List<Locale.LanguageRange> ranges = getAcceptLanguage();
    if (ranges.isEmpty()) {
        return Collections.emptyList();
    } 
    return ranges.stream().map(range -> Locale.forLanguageTag(range.getRange())).filter(locale -> StringUtils.hasText(locale.getDisplayName())).collect(Collectors.toList());
}
org.springframework.http.HttpHeaders
public boolean getAccessControlAllowCredentials()
{
    return Boolean.parseBoolean(getFirst(ACCESS_CONTROL_ALLOW_CREDENTIALS));
}
org.springframework.http.HttpHeaders
public List<String> getAccessControlAllowHeaders()
{
    return getValuesAsList(ACCESS_CONTROL_ALLOW_HEADERS);
}
org.springframework.http.HttpHeaders
@Nullable public String getAccessControlAllowOrigin()
{
    return getFieldValues(ACCESS_CONTROL_ALLOW_ORIGIN);
}
org.springframework.http.HttpHeaders
public List<String> getAccessControlExposeHeaders()
{
    return getValuesAsList(ACCESS_CONTROL_EXPOSE_HEADERS);
}
org.springframework.http.HttpHeaders
public long getAccessControlMaxAge()
{
    String value = getFirst(ACCESS_CONTROL_MAX_AGE);
    return (value != null ? Long.parseLong(value) : -1);
}
org.springframework.http.HttpHeaders
public List<String> getAccessControlRequestHeaders()
{
    return getValuesAsList(ACCESS_CONTROL_REQUEST_HEADERS);
}
org.springframework.http.HttpHeaders
@Nullable public HttpMethod getAccessControlRequestMethod()
{
    return HttpMethod.resolve(getFirst(ACCESS_CONTROL_REQUEST_METHOD));
}
org.springframework.http.HttpHeaders
@Nullable public String getCacheControl()
{
    return getFieldValues(CACHE_CONTROL);
}
org.springframework.http.HttpHeaders
public List<String> getConnection()
{
    return getValuesAsList(CONNECTION);
}
org.springframework.http.HttpHeaders
public ContentDisposition getContentDisposition()
{
    String contentDisposition = getFirst(CONTENT_DISPOSITION);
    if (contentDisposition != null) {
        return ContentDisposition.parse(contentDisposition);
    } 
    return ContentDisposition.empty();
}
org.springframework.http.HttpHeaders
@Nullable public Locale getContentLanguage()
{
    return getValuesAsList(CONTENT_LANGUAGE).stream().findFirst().map(Locale::forLanguageTag).orElse(null);
}
org.springframework.http.HttpHeaders
public long getContentLength()
{
    String value = getFirst(CONTENT_LENGTH);
    return (value != null ? Long.parseLong(value) : -1);
}
org.springframework.http.HttpHeaders
public long getDate()
{
    return getFirstDate(DATE);
}
org.springframework.http.HttpHeaders
@Nullable public String getETag()
{
    return getFirst(ETAG);
}
org.springframework.http.HttpHeaders
public long getExpires()
{
    return getFirstDate(EXPIRES, false);
}
org.springframework.http.HttpHeaders
@Nullable protected String getFieldValues(String headerName)
{
    List<String> headerValues = get(headerName);
    return (headerValues != null ? toCommaDelimitedString(headerValues) : null);
}
org.springframework.http.HttpHeaders
@Override @Nullable public String getFirst(String headerName)
{
    return this.headers.getFirst(headerName);
}
org.springframework.http.HttpHeaders
public long getFirstDate(String headerName)
{
    return getFirstDate(headerName, true);
}
org.springframework.http.HttpHeaders
@Nullable public ZonedDateTime getFirstZonedDateTime(String headerName)
{
    return getFirstZonedDateTime(headerName, true);
}
org.springframework.http.HttpHeaders
@Nullable public InetSocketAddress getHost()
{
    String value = getFirst(HOST);
    if (value == null) {
        return null;
    } 
    String host = null;
    int port = 0;
    int separator = (value.startsWith("[") ? value.indexOf(':', value.indexOf(']')) : value.lastIndexOf(':'));
    if (separator != -1) {
        host = value.substring(0, separator);
        String portString = value.substring(separator + 1);
        try {
            port = Integer.parseInt(portString);
        } catch (NumberFormatException ex) {
        }
    } 
    if (host == null) {
        host = value;
    } 
    return InetSocketAddress.createUnresolved(host, port);
}
org.springframework.http.HttpHeaders
public List<String> getIfMatch()
{
    return getETagValuesAsList(IF_MATCH);
}
org.springframework.http.HttpHeaders
public long getIfModifiedSince()
{
    return getFirstDate(IF_MODIFIED_SINCE, false);
}
org.springframework.http.HttpHeaders
public List<String> getIfNoneMatch()
{
    return getETagValuesAsList(IF_NONE_MATCH);
}
org.springframework.http.HttpHeaders
public long getIfUnmodifiedSince()
{
    return getFirstDate(IF_UNMODIFIED_SINCE, false);
}
org.springframework.http.HttpHeaders
public long getLastModified()
{
    return getFirstDate(LAST_MODIFIED, false);
}
org.springframework.http.HttpHeaders
@Nullable public URI getLocation()
{
    String value = getFirst(LOCATION);
    return (value != null ? URI.create(value) : null);
}
org.springframework.http.HttpHeaders
public List<String> getOrEmpty(Object headerName)
{
    List<String> values = get(headerName);
    return (values != null ? values : Collections.emptyList());
}
org.springframework.http.HttpHeaders
@Nullable public String getOrigin()
{
    return getFirst(ORIGIN);
}
org.springframework.http.HttpHeaders
@Nullable public String getPragma()
{
    return getFirst(PRAGMA);
}
org.springframework.http.HttpHeaders
public List<HttpRange> getRange()
{
    String value = getFirst(RANGE);
    return HttpRange.parseRanges(value);
}
org.springframework.http.HttpHeaders
@Nullable public String getUpgrade()
{
    return getFirst(UPGRADE);
}
org.springframework.http.HttpHeaders
public List<String> getVary()
{
    return getValuesAsList(VARY);
}
org.springframework.http.HttpHeaders
@Override public int hashCode()
{
    return this.headers.hashCode();
}
org.springframework.http.HttpHeaders
@Override public boolean isEmpty()
{
    return this.headers.isEmpty();
}
org.springframework.http.HttpHeaders
@Override public Set<String> keySet()
{
    return this.headers.keySet();
}
org.springframework.http.HttpHeaders
@Override public List<String> put(String key, List<String> value)
{
    return this.headers.put(key, value);
}
org.springframework.http.HttpHeaders
@Override public void putAll(Map<?, ?> map)
{
    this.headers.putAll(map);
}
org.springframework.http.HttpHeaders
@Override public List<String> remove(Object key)
{
    return this.headers.remove(key);
}
org.springframework.http.HttpHeaders
@Override public void set(String headerName, @Nullable String headerValue)
{
    this.headers.set(headerName, headerValue);
}
org.springframework.http.HttpHeaders
public void setAccept(List<MediaType> acceptableMediaTypes)
{
    set(ACCEPT, MediaType.toString(acceptableMediaTypes));
}
org.springframework.http.HttpHeaders
public void setAcceptCharset(List<Charset> acceptableCharsets)
{
    StringJoiner joiner = new StringJoiner(", ");
    for (Charset charset: acceptableCharsets) {
        joiner.add(charset.name().toLowerCase(Locale.ENGLISH));
    }
    set(ACCEPT_CHARSET, joiner.toString());
}
org.springframework.http.HttpHeaders
public void setAcceptLanguageAsLocales(List<Locale> locales)
{
    setAcceptLanguage(locales.stream().map(locale -> new Locale.LanguageRange(locale.toLanguageTag())).collect(Collectors.toList()));
}
org.springframework.http.HttpHeaders
public void setAccessControlAllowCredentials(boolean allowCredentials)
{
    set(ACCESS_CONTROL_ALLOW_CREDENTIALS, Boolean.toString(allowCredentials));
}
org.springframework.http.HttpHeaders
public void setAccessControlAllowHeaders(List<String> allowedHeaders)
{
    set(ACCESS_CONTROL_ALLOW_HEADERS, toCommaDelimitedString(allowedHeaders));
}
org.springframework.http.HttpHeaders
public void setAccessControlAllowMethods(List<HttpMethod> allowedMethods)
{
    set(ACCESS_CONTROL_ALLOW_METHODS, StringUtils.collectionToCommaDelimitedString(allowedMethods));
}
org.springframework.http.HttpHeaders
public void setAccessControlAllowOrigin(@Nullable String allowedOrigin)
{
    setOrRemove(ACCESS_CONTROL_ALLOW_ORIGIN, allowedOrigin);
}
org.springframework.http.HttpHeaders
public void setAccessControlExposeHeaders(List<String> exposedHeaders)
{
    set(ACCESS_CONTROL_EXPOSE_HEADERS, toCommaDelimitedString(exposedHeaders));
}
org.springframework.http.HttpHeaders
public void setAccessControlMaxAge(Duration maxAge)
{
    set(ACCESS_CONTROL_MAX_AGE, Long.toString(maxAge.getSeconds()));
}
org.springframework.http.HttpHeaders
public void setAccessControlMaxAge(long maxAge)
{
    set(ACCESS_CONTROL_MAX_AGE, Long.toString(maxAge));
}
org.springframework.http.HttpHeaders
public void setAccessControlRequestHeaders(List<String> requestHeaders)
{
    set(ACCESS_CONTROL_REQUEST_HEADERS, toCommaDelimitedString(requestHeaders));
}
org.springframework.http.HttpHeaders
public void setAccessControlRequestMethod(@Nullable HttpMethod requestMethod)
{
    setOrRemove(ACCESS_CONTROL_REQUEST_METHOD, (requestMethod != null ? requestMethod.name() : null));
}
org.springframework.http.HttpHeaders
@Override public void setAll(Map<String, String> values)
{
    this.headers.setAll(values);
}
org.springframework.http.HttpHeaders
public void setAllow(Set<HttpMethod> allowedMethods)
{
    set(ALLOW, StringUtils.collectionToCommaDelimitedString(allowedMethods));
}
org.springframework.http.HttpHeaders
public void setBasicAuth(String username, String password)
{
    setBasicAuth(username, password, null);
}
org.springframework.http.HttpHeaders
public void setBasicAuth(String username, String password, @Nullable Charset charset)
{
    setBasicAuth(encodeBasicAuth(username, password, charset));
}
org.springframework.http.HttpHeaders
public void setBearerAuth(String token)
{
    set(AUTHORIZATION, "Bearer " + token);
}
org.springframework.http.HttpHeaders
public void setCacheControl(CacheControl cacheControl)
{
    setOrRemove(CACHE_CONTROL, cacheControl.getHeaderValue());
}
org.springframework.http.HttpHeaders
public void setCacheControl(@Nullable String cacheControl)
{
    setOrRemove(CACHE_CONTROL, cacheControl);
}
org.springframework.http.HttpHeaders
public void setConnection(String connection)
{
    set(CONNECTION, connection);
}
org.springframework.http.HttpHeaders
public void setConnection(List<String> connection)
{
    set(CONNECTION, toCommaDelimitedString(connection));
}
org.springframework.http.HttpHeaders
public void setContentDisposition(ContentDisposition contentDisposition)
{
    set(CONTENT_DISPOSITION, contentDisposition.toString());
}
org.springframework.http.HttpHeaders
public void setContentDispositionFormData(String name, @Nullable String filename)
{
    Assert.notNull(name, "Name must not be null");
    ContentDisposition.Builder disposition = ContentDisposition.builder("form-data").name(name);
    if (filename != null) {
        disposition.filename(filename);
    } 
    setContentDisposition(disposition.build());
}
org.springframework.http.HttpHeaders
public void setContentLanguage(@Nullable Locale locale)
{
    setOrRemove(CONTENT_LANGUAGE, (locale != null ? locale.toLanguageTag() : null));
}
org.springframework.http.HttpHeaders
public void setContentLength(long contentLength)
{
    set(CONTENT_LENGTH, Long.toString(contentLength));
}
org.springframework.http.HttpHeaders
public void setDate(ZonedDateTime date)
{
    setZonedDateTime(DATE, date);
}
org.springframework.http.HttpHeaders
public void setDate(Instant date)
{
    setInstant(DATE, date);
}
org.springframework.http.HttpHeaders
public void setDate(long date)
{
    setDate(DATE, date);
}
org.springframework.http.HttpHeaders
public void setDate(String headerName, long date)
{
    setInstant(headerName, Instant.ofEpochMilli(date));
}
org.springframework.http.HttpHeaders
public void setExpires(ZonedDateTime expires)
{
    setZonedDateTime(EXPIRES, expires);
}
org.springframework.http.HttpHeaders
public void setExpires(Instant expires)
{
    setInstant(EXPIRES, expires);
}
org.springframework.http.HttpHeaders
public void setExpires(long expires)
{
    setDate(EXPIRES, expires);
}
org.springframework.http.HttpHeaders
public void setHost(@Nullable InetSocketAddress host)
{
    if (host != null) {
        String value = host.getHostString();
        int port = host.getPort();
        if (port != 0) {
            value = value + ":" + port;
        } 
        set(HOST, value);
    } else {
        remove(HOST, null);
    }
}
org.springframework.http.HttpHeaders
public void setIfMatch(String ifMatch)
{
    set(IF_MATCH, ifMatch);
}
org.springframework.http.HttpHeaders
public void setIfMatch(List<String> ifMatchList)
{
    set(IF_MATCH, toCommaDelimitedString(ifMatchList));
}
org.springframework.http.HttpHeaders
public void setIfModifiedSince(ZonedDateTime ifModifiedSince)
{
    setZonedDateTime(IF_MODIFIED_SINCE, ifModifiedSince.withZoneSameInstant(GMT));
}
org.springframework.http.HttpHeaders
public void setIfModifiedSince(Instant ifModifiedSince)
{
    setInstant(IF_MODIFIED_SINCE, ifModifiedSince);
}
org.springframework.http.HttpHeaders
public void setIfModifiedSince(long ifModifiedSince)
{
    setDate(IF_MODIFIED_SINCE, ifModifiedSince);
}
org.springframework.http.HttpHeaders
public void setIfNoneMatch(String ifNoneMatch)
{
    set(IF_NONE_MATCH, ifNoneMatch);
}
org.springframework.http.HttpHeaders
public void setIfNoneMatch(List<String> ifNoneMatchList)
{
    set(IF_NONE_MATCH, toCommaDelimitedString(ifNoneMatchList));
}
org.springframework.http.HttpHeaders
public void setIfUnmodifiedSince(ZonedDateTime ifUnmodifiedSince)
{
    setZonedDateTime(IF_UNMODIFIED_SINCE, ifUnmodifiedSince.withZoneSameInstant(GMT));
}
org.springframework.http.HttpHeaders
public void setIfUnmodifiedSince(Instant ifUnmodifiedSince)
{
    setInstant(IF_UNMODIFIED_SINCE, ifUnmodifiedSince);
}
org.springframework.http.HttpHeaders
public void setIfUnmodifiedSince(long ifUnmodifiedSince)
{
    setDate(IF_UNMODIFIED_SINCE, ifUnmodifiedSince);
}
org.springframework.http.HttpHeaders
public void setInstant(String headerName, Instant date)
{
    setZonedDateTime(headerName, ZonedDateTime.ofInstant(date, GMT));
}
org.springframework.http.HttpHeaders
public void setLastModified(ZonedDateTime lastModified)
{
    setZonedDateTime(LAST_MODIFIED, lastModified.withZoneSameInstant(GMT));
}
org.springframework.http.HttpHeaders
public void setLastModified(Instant lastModified)
{
    setInstant(LAST_MODIFIED, lastModified);
}
org.springframework.http.HttpHeaders
public void setLastModified(long lastModified)
{
    setDate(LAST_MODIFIED, lastModified);
}
org.springframework.http.HttpHeaders
public void setLocation(@Nullable URI location)
{
    setOrRemove(LOCATION, (location != null ? location.toASCIIString() : null));
}
org.springframework.http.HttpHeaders
public void setOrigin(@Nullable String origin)
{
    setOrRemove(ORIGIN, origin);
}
org.springframework.http.HttpHeaders
public void setPragma(@Nullable String pragma)
{
    setOrRemove(PRAGMA, pragma);
}
org.springframework.http.HttpHeaders
public void setRange(List<HttpRange> ranges)
{
    String value = HttpRange.toString(ranges);
    set(RANGE, value);
}
org.springframework.http.HttpHeaders
public void setUpgrade(@Nullable String upgrade)
{
    setOrRemove(UPGRADE, upgrade);
}
org.springframework.http.HttpHeaders
public void setVary(List<String> requestHeaders)
{
    set(VARY, toCommaDelimitedString(requestHeaders));
}
org.springframework.http.HttpHeaders
public void setZonedDateTime(String headerName, ZonedDateTime date)
{
    set(headerName, DATE_FORMATTER.format(date));
}
org.springframework.http.HttpHeaders
@Override public int size()
{
    return this.headers.size();
}
org.springframework.http.HttpHeaders
protected String toCommaDelimitedString(List<String> headerValues)
{
    StringJoiner joiner = new StringJoiner(", ");
    for (String val: headerValues) {
        if (val != null) {
            joiner.add(val);
        } 
    }
    return joiner.toString();
}
org.springframework.http.HttpHeaders
@Override public Map<String, String> toSingleValueMap()
{
    return this.headers.toSingleValueMap();
}
org.springframework.http.HttpHeaders
@Override public String toString()
{
    return formatHeaders(this.headers);
}
org.springframework.http.HttpHeaders
@Override public Collection<List<String>> values()
{
    return this.headers.values();
}
org.springframework.http.HttpHeaders
public static HttpHeaders writableHttpHeaders(HttpHeaders headers)
{
    Assert.notNull(headers, "HttpHeaders must not be null");
    if (headers == EMPTY) {
        return new HttpHeaders();
    } else if (headers instanceof ReadOnlyHttpHeaders) {
        return new HttpHeaders(headers.headers);
    } else {
        return headers;
    }
}
 HttpInputMessage
inherit classes
  • HttpMessage
 HttpLogging
org.springframework.http.HttpLogging
public static Log forLog(Log primaryLogger)
{
    return LogDelegateFactory.getCompositeLog(primaryLogger, fallbackLogger);
}
org.springframework.http.HttpLogging
public static Log forLogName(Class<?> primaryLoggerClass)
{
    Log primaryLogger = LogFactory.getLog(primaryLoggerClass);
    return forLog(primaryLogger);
}
 HttpMessage
HttpMethod
enum values
  • GET
  • HEAD
  • POST
  • PUT
  • PATCH
  • DELETE
  • OPTIONS
  • TRACE
org.springframework.http
public boolean matches(String method)
{
    return (this == resolve(method));
}
org.springframework.http
@Nullable public static HttpMethod resolve(@Nullable String method)
{
    return (method != null ? mappings.get(method) : null);
}
 HttpOutputMessage
inherit classes
  • HttpMessage
 HttpRange
org.springframework.http.HttpRange
public static HttpRange createByteRange(long firstBytePos)
{
    return new ByteRange(firstBytePos, null);
}
org.springframework.http.HttpRange
public static HttpRange createByteRange(long firstBytePos, long lastBytePos)
{
    return new ByteRange(firstBytePos, lastBytePos);
}
org.springframework.http.HttpRange
public static HttpRange createSuffixRange(long suffixLength)
{
    return new SuffixByteRange(suffixLength);
}
org.springframework.http.HttpRange
public abstract long getRangeEnd(long length)
org.springframework.http.HttpRange
public abstract long getRangeStart(long length)
org.springframework.http.HttpRange
public static List<HttpRange> parseRanges(@Nullable String ranges)
{
    if (!StringUtils.hasLength(ranges)) {
        return Collections.emptyList();
    } 
    if (!ranges.startsWith(BYTE_RANGE_PREFIX)) {
        throw new IllegalArgumentException("Range '" + ranges + "' does not start with 'bytes='");
    } 
    ranges = ranges.substring(BYTE_RANGE_PREFIX.length());
    String[] tokens = StringUtils.tokenizeToStringArray(ranges, ",");
    if (tokens.length > MAX_RANGES) {
        throw new IllegalArgumentException("Too many ranges: " + tokens.length);
    } 
    List<HttpRange> result = new ArrayList<>(tokens.length);
    for (String token: tokens) {
        result.add(parseRange(token));
    }
    return result;
}
org.springframework.http.HttpRange
public static List<ResourceRegion> toResourceRegions(List<HttpRange> ranges, Resource resource)
{
    if (CollectionUtils.isEmpty(ranges)) {
        return Collections.emptyList();
    } 
    List<ResourceRegion> regions = new ArrayList<>(ranges.size());
    for (HttpRange range: ranges) {
        regions.add(range.toResourceRegion(resource));
    }
    if (ranges.size() > 1) {
        long length = getLengthFor(resource);
        long total = 0;
        for (ResourceRegion region: regions) {
            total += region.getCount();
        }
        if (total >= length) {
            throw new IllegalArgumentException("The sum of all ranges (" + total + ") should be less than the resource length (" + length + ")");
        } 
    } 
    return regions;
}
 HttpRequest
inherit classes
  • HttpMessage
HttpStatus
enum values
  • CONTINUE
  • SWITCHING_PROTOCOLS
  • PROCESSING
  • CHECKPOINT
  • OK
  • CREATED
  • ACCEPTED
  • NON_AUTHORITATIVE_INFORMATION
  • NO_CONTENT
  • RESET_CONTENT
  • PARTIAL_CONTENT
  • MULTI_STATUS
  • ALREADY_REPORTED
  • IM_USED
  • MULTIPLE_CHOICES
  • MOVED_PERMANENTLY
  • FOUND
  • MOVED_TEMPORARILY
  • SEE_OTHER
  • NOT_MODIFIED
  • USE_PROXY
  • TEMPORARY_REDIRECT
  • PERMANENT_REDIRECT
  • BAD_REQUEST
  • UNAUTHORIZED
  • PAYMENT_REQUIRED
  • FORBIDDEN
  • NOT_FOUND
  • METHOD_NOT_ALLOWED
  • NOT_ACCEPTABLE
  • PROXY_AUTHENTICATION_REQUIRED
  • REQUEST_TIMEOUT
  • CONFLICT
  • GONE
  • LENGTH_REQUIRED
  • PRECONDITION_FAILED
  • PAYLOAD_TOO_LARGE
  • REQUEST_ENTITY_TOO_LARGE
  • URI_TOO_LONG
  • REQUEST_URI_TOO_LONG
  • UNSUPPORTED_MEDIA_TYPE
  • REQUESTED_RANGE_NOT_SATISFIABLE
  • EXPECTATION_FAILED
  • I_AM_A_TEAPOT
  • INSUFFICIENT_SPACE_ON_RESOURCE
  • METHOD_FAILURE
  • DESTINATION_LOCKED
  • UNPROCESSABLE_ENTITY
  • LOCKED
  • FAILED_DEPENDENCY
  • TOO_EARLY
  • UPGRADE_REQUIRED
  • PRECONDITION_REQUIRED
  • TOO_MANY_REQUESTS
  • REQUEST_HEADER_FIELDS_TOO_LARGE
  • UNAVAILABLE_FOR_LEGAL_REASONS
  • INTERNAL_SERVER_ERROR
  • NOT_IMPLEMENTED
  • BAD_GATEWAY
  • SERVICE_UNAVAILABLE
  • GATEWAY_TIMEOUT
  • HTTP_VERSION_NOT_SUPPORTED
  • VARIANT_ALSO_NEGOTIATES
  • INSUFFICIENT_STORAGE
  • LOOP_DETECTED
  • BANDWIDTH_LIMIT_EXCEEDED
  • NOT_EXTENDED
  • NETWORK_AUTHENTICATION_REQUIRED
Series
enum values
  • INFORMATIONAL
  • SUCCESSFUL
  • REDIRECTION
  • CLIENT_ERROR
  • SERVER_ERROR
org.springframework.http
@Nullable public static Series resolve(int statusCode)
{
    int seriesCode = statusCode / 100;
    for (Series series: values()) {
        if (series.value == seriesCode) {
            return series;
        } 
    }
    return null;
}
org.springframework.http
public int value()
{
    return this.value;
}
org.springframework.http
public static Series valueOf(HttpStatus status)
{
    return valueOf(status.value);
}
org.springframework.http
public String getReasonPhrase()
{
    return this.reasonPhrase;
}
org.springframework.http
public boolean is1xxInformational()
{
    return (series() == Series.INFORMATIONAL);
}
org.springframework.http
public boolean is2xxSuccessful()
{
    return (series() == Series.SUCCESSFUL);
}
org.springframework.http
public boolean is3xxRedirection()
{
    return (series() == Series.REDIRECTION);
}
org.springframework.http
public boolean is4xxClientError()
{
    return (series() == Series.CLIENT_ERROR);
}
org.springframework.http
public boolean is5xxServerError()
{
    return (series() == Series.SERVER_ERROR);
}
org.springframework.http
public boolean isError()
{
    return (is4xxClientError() || is5xxServerError());
}
org.springframework.http
@Nullable public static HttpStatus resolve(int statusCode)
{
    for (HttpStatus status: values()) {
        if (status.value == statusCode) {
            return status;
        } 
    }
    return null;
}
org.springframework.http
public Series series()
{
    return Series.valueOf(this);
}
org.springframework.http
@Override public String toString()
{
    return this.value + " " + name();
}
org.springframework.http
public int value()
{
    return this.value;
}
 InvalidMediaTypeException
 extends IllegalArgumentException
org.springframework.http.InvalidMediaTypeException
public InvalidMediaTypeException InvalidMediaTypeException(String mediaType, String message)
{
    super("Invalid media type \"" + mediaType + "\": " + message);
    this.mediaType = mediaType;
}
org.springframework.http.InvalidMediaTypeException
public String getMediaType()
{
    return this.mediaType;
}
 MediaType
 extends MimeType implements Serializable
org.springframework.http.MediaType
public static final MediaType ALL
org.springframework.http.MediaType
public static final String ALL_VALUE
org.springframework.http.MediaType
public static final MediaType APPLICATION_ATOM_XML
org.springframework.http.MediaType
public static final String APPLICATION_ATOM_XML_VALUE
org.springframework.http.MediaType
public static final MediaType APPLICATION_CBOR
org.springframework.http.MediaType
public static final String APPLICATION_CBOR_VALUE
org.springframework.http.MediaType
public static final MediaType APPLICATION_FORM_URLENCODED
org.springframework.http.MediaType
public static final String APPLICATION_FORM_URLENCODED_VALUE
org.springframework.http.MediaType
public static final MediaType APPLICATION_JSON
org.springframework.http.MediaType
@Deprecated public static final MediaType APPLICATION_JSON_UTF8
org.springframework.http.MediaType
@Deprecated public static final String APPLICATION_JSON_UTF8_VALUE
org.springframework.http.MediaType
public static final String APPLICATION_JSON_VALUE
org.springframework.http.MediaType
public static final MediaType APPLICATION_OCTET_STREAM
org.springframework.http.MediaType
public static final String APPLICATION_OCTET_STREAM_VALUE
org.springframework.http.MediaType
public static final MediaType APPLICATION_PDF
org.springframework.http.MediaType
public static final String APPLICATION_PDF_VALUE
org.springframework.http.MediaType
public static final MediaType APPLICATION_PROBLEM_JSON
org.springframework.http.MediaType
@Deprecated public static final MediaType APPLICATION_PROBLEM_JSON_UTF8
org.springframework.http.MediaType
@Deprecated public static final String APPLICATION_PROBLEM_JSON_UTF8_VALUE
org.springframework.http.MediaType
public static final String APPLICATION_PROBLEM_JSON_VALUE
org.springframework.http.MediaType
public static final MediaType APPLICATION_PROBLEM_XML
org.springframework.http.MediaType
public static final String APPLICATION_PROBLEM_XML_VALUE
org.springframework.http.MediaType
public static final MediaType APPLICATION_RSS_XML
org.springframework.http.MediaType
public static final String APPLICATION_RSS_XML_VALUE
org.springframework.http.MediaType
public static final MediaType APPLICATION_STREAM_JSON
org.springframework.http.MediaType
public static final String APPLICATION_STREAM_JSON_VALUE
org.springframework.http.MediaType
public static final MediaType APPLICATION_XHTML_XML
org.springframework.http.MediaType
public static final String APPLICATION_XHTML_XML_VALUE
org.springframework.http.MediaType
public static final MediaType APPLICATION_XML
org.springframework.http.MediaType
public static final String APPLICATION_XML_VALUE
org.springframework.http.MediaType
public static final MediaType IMAGE_GIF
org.springframework.http.MediaType
public static final String IMAGE_GIF_VALUE
org.springframework.http.MediaType
public static final MediaType IMAGE_JPEG
org.springframework.http.MediaType
public static final String IMAGE_JPEG_VALUE
org.springframework.http.MediaType
public static final MediaType IMAGE_PNG
org.springframework.http.MediaType
public static final String IMAGE_PNG_VALUE
org.springframework.http.MediaType
public static final MediaType MULTIPART_FORM_DATA
org.springframework.http.MediaType
public static final String MULTIPART_FORM_DATA_VALUE
org.springframework.http.MediaType
public static final MediaType MULTIPART_MIXED
org.springframework.http.MediaType
public static final String MULTIPART_MIXED_VALUE
org.springframework.http.MediaType
public MediaType MediaType(String type)
{
    super(type);
}
org.springframework.http.MediaType
public MediaType MediaType(String type, String subtype)
{
    super(type, subtype, Collections.emptyMap());
}
org.springframework.http.MediaType
public MediaType MediaType(String type, String subtype, Charset charset)
{
    super(type, subtype, charset);
}
org.springframework.http.MediaType
public MediaType MediaType(String type, String subtype, double qualityValue)
{
    this(type, subtype, Collections.singletonMap(PARAM_QUALITY_FACTOR, Double.toString(qualityValue)));
}
org.springframework.http.MediaType
public MediaType MediaType(MediaType other, Charset charset)
{
    super(other, charset);
}
org.springframework.http.MediaType
public MediaType MediaType(MediaType other, @Nullable Map<String, String> parameters)
{
    super(other.getType(), other.getSubtype(), parameters);
}
org.springframework.http.MediaType
public MediaType MediaType(String type, String subtype, @Nullable Map<String, String> parameters)
{
    super(type, subtype, parameters);
}
org.springframework.http.MediaType
public static final Comparator<MediaType> QUALITY_VALUE_COMPARATOR
org.springframework.http.MediaType
public static final Comparator<MediaType> SPECIFICITY_COMPARATOR
org.springframework.http.MediaType
public static final MediaType TEXT_EVENT_STREAM
org.springframework.http.MediaType
public static final String TEXT_EVENT_STREAM_VALUE
org.springframework.http.MediaType
public static final MediaType TEXT_HTML
org.springframework.http.MediaType
public static final String TEXT_HTML_VALUE
org.springframework.http.MediaType
public static final MediaType TEXT_MARKDOWN
org.springframework.http.MediaType
public static final String TEXT_MARKDOWN_VALUE
org.springframework.http.MediaType
public static final MediaType TEXT_PLAIN
org.springframework.http.MediaType
public static final String TEXT_PLAIN_VALUE
org.springframework.http.MediaType
public static final MediaType TEXT_XML
org.springframework.http.MediaType
public static final String TEXT_XML_VALUE
org.springframework.http.MediaType
public static MediaType asMediaType(MimeType mimeType)
{
    if (mimeType instanceof MediaType) {
        return (MediaType)mimeType;
    } 
    return new MediaType(mimeType.getType(), mimeType.getSubtype(), mimeType.getParameters());
}
org.springframework.http.MediaType
public static List<MediaType> asMediaTypes(List<MimeType> mimeTypes)
{
    List<MediaType> mediaTypes = new ArrayList<>(mimeTypes.size());
    for (MimeType mimeType: mimeTypes) {
        mediaTypes.add(MediaType.asMediaType(mimeType));
    }
    return mediaTypes;
}
org.springframework.http.MediaType
public MediaType copyQualityValue(MediaType mediaType)
{
    if (!mediaType.getParameters().containsKey(PARAM_QUALITY_FACTOR)) {
        return this;
    } 
    Map<String, String> params = new LinkedHashMap<>(getParameters());
    params.put(PARAM_QUALITY_FACTOR, mediaType.getParameters().get(PARAM_QUALITY_FACTOR));
    return new MediaType(this, params);
}
org.springframework.http.MediaType
public boolean includes(@Nullable MediaType other)
{
    return super.includes(other);
}
org.springframework.http.MediaType
public boolean isCompatibleWith(@Nullable MediaType other)
{
    return super.isCompatibleWith(other);
}
org.springframework.http.MediaType
public static List<MediaType> parseMediaTypes(@Nullable String mediaTypes)
{
    if (!StringUtils.hasLength(mediaTypes)) {
        return Collections.emptyList();
    } 
    List<String> tokenizedTypes = MimeTypeUtils.tokenize(mediaTypes);
    List<MediaType> result = new ArrayList<>(tokenizedTypes.size());
    for (String type: tokenizedTypes) {
        if (StringUtils.hasText(type)) {
            result.add(parseMediaType(type));
        } 
    }
    return result;
}
org.springframework.http.MediaType
public static List<MediaType> parseMediaTypes(@Nullable List<String> mediaTypes)
{
    if (CollectionUtils.isEmpty(mediaTypes)) {
        return Collections.emptyList();
    } else if (mediaTypes.size() == 1) {
        return parseMediaTypes(mediaTypes.get(0));
    } else {
        List<MediaType> result = new ArrayList<>(8);
        for (String mediaType: mediaTypes) {
            result.addAll(parseMediaTypes(mediaType));
        }
        return result;
    }
}
org.springframework.http.MediaType
public MediaType removeQualityValue()
{
    if (!getParameters().containsKey(PARAM_QUALITY_FACTOR)) {
        return this;
    } 
    Map<String, String> params = new LinkedHashMap<>(getParameters());
    params.remove(PARAM_QUALITY_FACTOR);
    return new MediaType(this, params);
}
org.springframework.http.MediaType
public static void sortByQualityValue(List<MediaType> mediaTypes)
{
    Assert.notNull(mediaTypes, "'mediaTypes' must not be null");
    if (mediaTypes.size() > 1) {
        mediaTypes.sort(QUALITY_VALUE_COMPARATOR);
    } 
}
org.springframework.http.MediaType
public static void sortBySpecificity(List<MediaType> mediaTypes)
{
    Assert.notNull(mediaTypes, "'mediaTypes' must not be null");
    if (mediaTypes.size() > 1) {
        mediaTypes.sort(SPECIFICITY_COMPARATOR);
    } 
}
org.springframework.http.MediaType
public static String toString(Collection<MediaType> mediaTypes)
{
    return MimeTypeUtils.toString(mediaTypes);
}
org.springframework.http.MediaType
public static MediaType valueOf(String value)
{
    return parseMediaType(value);
}
 MediaTypeEditor
 extends PropertyEditorSupport
org.springframework.http.MediaTypeEditor
@Override public String getAsText()
{
    MediaType mediaType = (MediaType)getValue();
    return (mediaType != null ? mediaType.toString() : "");
}
org.springframework.http.MediaTypeEditor
@Override public void setAsText(String text)
{
    if (StringUtils.hasText(text)) {
        setValue(MediaType.parseMediaType(text));
    } else {
        setValue(null);
    }
}
 MediaTypeFactory
org.springframework.http.MediaTypeFactory
public static Optional<MediaType> getMediaType(@Nullable Resource resource)
{
    return Optional.ofNullable(resource).map(Resource::getFilename).flatMap(MediaTypeFactory::getMediaType);
}
org.springframework.http.MediaTypeFactory
public static Optional<MediaType> getMediaType(@Nullable String filename)
{
    return getMediaTypes(filename).stream().findFirst();
}
 ReactiveHttpInputMessage
inherit classes
  • HttpMessage
 ReactiveHttpOutputMessage
inherit classes
  • HttpMessage
 ReadOnlyHttpHeaders
 extends HttpHeaders
org.springframework.http.ReadOnlyHttpHeaders
@Override public void add(String headerName, @Nullable String headerValue)
{
    throw new UnsupportedOperationException();
}
org.springframework.http.ReadOnlyHttpHeaders
@Override public void addAll(String key, List<?> values)
{
    throw new UnsupportedOperationException();
}
org.springframework.http.ReadOnlyHttpHeaders
@Override public void addAll(MultiValueMap<String, String> values)
{
    throw new UnsupportedOperationException();
}
org.springframework.http.ReadOnlyHttpHeaders
@Override public void clear()
{
    throw new UnsupportedOperationException();
}
org.springframework.http.ReadOnlyHttpHeaders
@Override public List<String> get(Object key)
{
    List<String> values = this.headers.get(key);
    return (values != null ? Collections.unmodifiableList(values) : null);
}
org.springframework.http.ReadOnlyHttpHeaders
@Override public Set<String> keySet()
{
    return Collections.unmodifiableSet(this.headers.keySet());
}
org.springframework.http.ReadOnlyHttpHeaders
@Override public List<String> put(String key, List<String> value)
{
    throw new UnsupportedOperationException();
}
org.springframework.http.ReadOnlyHttpHeaders
@Override public void putAll(Map<?, ?> map)
{
    throw new UnsupportedOperationException();
}
org.springframework.http.ReadOnlyHttpHeaders
@Override public List<String> remove(Object key)
{
    throw new UnsupportedOperationException();
}
org.springframework.http.ReadOnlyHttpHeaders
@Override public void set(String headerName, @Nullable String headerValue)
{
    throw new UnsupportedOperationException();
}
org.springframework.http.ReadOnlyHttpHeaders
@Override public void setAll(Map<String, String> values)
{
    throw new UnsupportedOperationException();
}
org.springframework.http.ReadOnlyHttpHeaders
@Override public Map<String, String> toSingleValueMap()
{
    return Collections.unmodifiableMap(this.headers.toSingleValueMap());
}
org.springframework.http.ReadOnlyHttpHeaders
@Override public Collection<List<String>> values()
{
    return Collections.unmodifiableCollection(this.headers.values());
}
 RequestEntity<T>
 extends HttpEntity<T>
 BodyBuilder
inherit classes
  • HeadersBuilder<BodyBuilder>
 HeadersBuilder
org.springframework.http.RequestEntity
public RequestEntity RequestEntity(HttpMethod method, URI url)
{
    this(null, null, method, url, null);
}
org.springframework.http.RequestEntity
public RequestEntity RequestEntity(@Nullable T body, HttpMethod method, URI url)
{
    this(body, null, method, url, null);
}
org.springframework.http.RequestEntity
public RequestEntity RequestEntity(@Nullable T body, HttpMethod method, URI url, Type type)
{
    this(body, null, method, url, type);
}
org.springframework.http.RequestEntity
public RequestEntity RequestEntity(MultiValueMap<String, String> headers, HttpMethod method, URI url)
{
    this(null, headers, method, url, null);
}
org.springframework.http.RequestEntity
public RequestEntity RequestEntity(@Nullable T body, @Nullable MultiValueMap<String, String> headers, @Nullable HttpMethod method, URI url)
{
    this(body, headers, method, url, null);
}
org.springframework.http.RequestEntity
public RequestEntity RequestEntity(@Nullable T body, @Nullable MultiValueMap<String, String> headers, @Nullable HttpMethod method, URI url, @Nullable Type type)
{
    super(body, headers);
    this.method = method;
    this.url = url;
    this.type = type;
}
org.springframework.http.RequestEntity
public static HeadersBuilder<?> delete(URI url)
{
    return method(HttpMethod.DELETE, url);
}
org.springframework.http.RequestEntity
@Override public boolean equals(@Nullable Object other)
{
    if (this == other) {
        return true;
    } 
    if (!super.equals(other)) {
        return false;
    } 
    RequestEntity<?> otherEntity = (RequestEntity<?>)other;
    return (ObjectUtils.nullSafeEquals(getMethod(), otherEntity.getMethod()) && ObjectUtils.nullSafeEquals(getUrl(), otherEntity.getUrl()));
}
org.springframework.http.RequestEntity
public static HeadersBuilder<?> get(URI url)
{
    return method(HttpMethod.GET, url);
}
org.springframework.http.RequestEntity
@Nullable public HttpMethod getMethod()
{
    return this.method;
}
org.springframework.http.RequestEntity
@Nullable public Type getType()
{
    if (this.type == null) {
        T body = getBody();
        if (body != null) {
            return body.getClass();
        } 
    } 
    return this.type;
}
org.springframework.http.RequestEntity
public URI getUrl()
{
    return this.url;
}
org.springframework.http.RequestEntity
public static HeadersBuilder<?> head(URI url)
{
    return method(HttpMethod.HEAD, url);
}
org.springframework.http.RequestEntity
public static BodyBuilder method(HttpMethod method, URI url)
{
    return new DefaultBodyBuilder(method, url);
}
org.springframework.http.RequestEntity
public static HeadersBuilder<?> options(URI url)
{
    return method(HttpMethod.OPTIONS, url);
}
org.springframework.http.RequestEntity
public static BodyBuilder patch(URI url)
{
    return method(HttpMethod.PATCH, url);
}
org.springframework.http.RequestEntity
public static BodyBuilder post(URI url)
{
    return method(HttpMethod.POST, url);
}
org.springframework.http.RequestEntity
public static BodyBuilder put(URI url)
{
    return method(HttpMethod.PUT, url);
}
 ResponseCookie
 extends HttpCookie
 ResponseCookieBuilder
org.springframework.http.ResponseCookie
@Override public boolean equals(@Nullable Object other)
{
    if (this == other) {
        return true;
    } 
    if (!(other instanceof ResponseCookie)) {
        return false;
    } 
    ResponseCookie otherCookie = (ResponseCookie)other;
    return (getName().equalsIgnoreCase(otherCookie.getName()) && ObjectUtils.nullSafeEquals(this.path, otherCookie.getPath()) && ObjectUtils.nullSafeEquals(this.domain, otherCookie.getDomain()));
}
org.springframework.http.ResponseCookie
public static ResponseCookieBuilder from(final String name, final String value)
{
    return new ResponseCookieBuilder() {
        private Duration maxAge = Duration.ofSeconds(-1);
        @Nullable
        private String domain;
        @Nullable
        private String path;
        private boolean secure;
        private boolean httpOnly;
        @Nullable
        private String sameSite;
        @Override
        public ResponseCookieBuilder maxAge(DurationmaxAge) {
            this.maxAge = maxAge;
            return this;
        }
        @Override
        public ResponseCookieBuilder maxAge(longmaxAgeSeconds) {
            this.maxAge = maxAgeSeconds >= 0 ? Duration.ofSeconds(maxAgeSeconds) : Duration.ofSeconds(-1);
            return this;
        }
        @Override
        public ResponseCookieBuilder domain(Stringdomain) {
            this.domain = domain;
            return this;
        }
        @Override
        public ResponseCookieBuilder path(Stringpath) {
            this.path = path;
            return this;
        }
        @Override
        public ResponseCookieBuilder secure(booleansecure) {
            this.secure = secure;
            return this;
        }
        @Override
        public ResponseCookieBuilder httpOnly(booleanhttpOnly) {
            this.httpOnly = httpOnly;
            return this;
        }
        @Override
        public ResponseCookieBuilder sameSite(@NullableStringsameSite) {
            this.sameSite = sameSite;
            return this;
        }
        @Override
        public ResponseCookie build() {
            return new ResponseCookie(name, value, this.maxAge, this.domain, this.path, this.secure, this.httpOnly, this.sameSite);
        }
    };
}
org.springframework.http.ResponseCookie
@Nullable public String getDomain()
{
    return this.domain;
}
org.springframework.http.ResponseCookie
public Duration getMaxAge()
{
    return this.maxAge;
}
org.springframework.http.ResponseCookie
@Nullable public String getPath()
{
    return this.path;
}
org.springframework.http.ResponseCookie
@Nullable public String getSameSite()
{
    return this.sameSite;
}
org.springframework.http.ResponseCookie
public boolean isHttpOnly()
{
    return this.httpOnly;
}
org.springframework.http.ResponseCookie
public boolean isSecure()
{
    return this.secure;
}
 ResponseEntity<T>
 extends HttpEntity<T>
 BodyBuilder
inherit classes
  • HeadersBuilder<BodyBuilder>
 HeadersBuilder
org.springframework.http.ResponseEntity
public ResponseEntity ResponseEntity(HttpStatus status)
{
    this(null, null, status);
}
org.springframework.http.ResponseEntity
public ResponseEntity ResponseEntity(@Nullable T body, HttpStatus status)
{
    this(body, null, status);
}
org.springframework.http.ResponseEntity
public ResponseEntity ResponseEntity(MultiValueMap<String, String> headers, HttpStatus status)
{
    this(null, headers, status);
}
org.springframework.http.ResponseEntity
public ResponseEntity ResponseEntity(@Nullable T body, @Nullable MultiValueMap<String, String> headers, HttpStatus status)
{
    super(body, headers);
    Assert.notNull(status, "HttpStatus must not be null");
    this.status = status;
}
org.springframework.http.ResponseEntity
public static BodyBuilder accepted()
{
    return status(HttpStatus.ACCEPTED);
}
org.springframework.http.ResponseEntity
public static BodyBuilder badRequest()
{
    return status(HttpStatus.BAD_REQUEST);
}
org.springframework.http.ResponseEntity
public static BodyBuilder created(URI location)
{
    BodyBuilder builder = status(HttpStatus.CREATED);
    return builder.location(location);
}
org.springframework.http.ResponseEntity
@Override public boolean equals(@Nullable Object other)
{
    if (this == other) {
        return true;
    } 
    if (!super.equals(other)) {
        return false;
    } 
    ResponseEntity<?> otherEntity = (ResponseEntity<?>)other;
    return ObjectUtils.nullSafeEquals(this.status, otherEntity.status);
}
org.springframework.http.ResponseEntity
@Override public int hashCode()
{
    return (29 * super.hashCode() + ObjectUtils.nullSafeHashCode(this.status));
}
org.springframework.http.ResponseEntity
public static HeadersBuilder<?> noContent()
{
    return status(HttpStatus.NO_CONTENT);
}
org.springframework.http.ResponseEntity
public static HeadersBuilder<?> notFound()
{
    return status(HttpStatus.NOT_FOUND);
}
org.springframework.http.ResponseEntity
<T>public static ResponseEntity<T> of(Optional<T> body)
{
    Assert.notNull(body, "Body must not be null");
    return body.map(ResponseEntity::ok).orElse(notFound().build());
}
org.springframework.http.ResponseEntity
public static BodyBuilder ok()
{
    return status(HttpStatus.OK);
}
org.springframework.http.ResponseEntity
<T>public static ResponseEntity<T> ok(T body)
{
    BodyBuilder builder = ok();
    return builder.body(body);
}
org.springframework.http.ResponseEntity
public static BodyBuilder status(HttpStatus status)
{
    Assert.notNull(status, "HttpStatus must not be null");
    return new DefaultBuilder(status);
}
org.springframework.http.ResponseEntity
public static BodyBuilder status(int status)
{
    return new DefaultBuilder(status);
}
org.springframework.http.ResponseEntity
@Override public String toString()
{
    StringBuilder builder = new StringBuilder("<");
    builder.append(this.status.toString());
    if (this.status instanceof HttpStatus) {
        builder.append(' ');
        builder.append(((HttpStatus)this.status).getReasonPhrase());
    } 
    builder.append(',');
    T body = getBody();
    HttpHeaders headers = getHeaders();
    if (body != null) {
        builder.append(body);
        builder.append(',');
    } 
    builder.append(headers);
    builder.append('>');
    return builder.toString();
}
org.springframework.http.ResponseEntity
public static BodyBuilder unprocessableEntity()
{
    return status(HttpStatus.UNPROCESSABLE_ENTITY);
}
 StreamingHttpOutputMessage
inherit classes
  • HttpOutputMessage
 ZeroCopyHttpOutputMessage
inherit classes
  • ReactiveHttpOutputMessage
 AbstractAsyncClientHttpRequest
 implements AsyncClientHttpRequest
org.springframework.http.client.AbstractAsyncClientHttpRequest
protected void assertNotExecuted()
{
    Assert.state(!this.executed, "ClientHttpRequest already executed");
}
org.springframework.http.client.AbstractAsyncClientHttpRequest
@Override public ListenableFuture<ClientHttpResponse> executeAsync()
{
    assertNotExecuted();
    ListenableFuture<ClientHttpResponse> result = executeInternal(this.headers);
    this.executed = true;
    return result;
}
org.springframework.http.client.AbstractAsyncClientHttpRequest
protected abstract ListenableFuture<ClientHttpResponse> executeInternal(HttpHeaders headers)
org.springframework.http.client.AbstractAsyncClientHttpRequest
@Override public final OutputStream getBody()
{
    assertNotExecuted();
    return getBodyInternal(this.headers);
}
org.springframework.http.client.AbstractAsyncClientHttpRequest
protected abstract OutputStream getBodyInternal(HttpHeaders headers)
org.springframework.http.client.AbstractAsyncClientHttpRequest
@Override public final HttpHeaders getHeaders()
{
    return (this.executed ? HttpHeaders.readOnlyHttpHeaders(this.headers) : this.headers);
}
 AbstractBufferingAsyncClientHttpRequest
 extends AbstractAsyncClientHttpRequest
org.springframework.http.client.AbstractBufferingAsyncClientHttpRequest
@Override protected ListenableFuture<ClientHttpResponse> executeInternal(HttpHeaders headers)
{
    byte[] bytes = this.bufferedOutput.toByteArray();
    if (headers.getContentLength() < 0) {
        headers.setContentLength(bytes.length);
    } 
    ListenableFuture<ClientHttpResponse> result = executeInternal(headers, bytes);
    this.bufferedOutput = new ByteArrayOutputStream(0);
    return result;
}
org.springframework.http.client.AbstractBufferingAsyncClientHttpRequest
protected abstract ListenableFuture<ClientHttpResponse> executeInternal(HttpHeaders headers, byte[] bufferedOutput)
org.springframework.http.client.AbstractBufferingAsyncClientHttpRequest
@Override protected OutputStream getBodyInternal(HttpHeaders headers)
{
    return this.bufferedOutput;
}
 AbstractBufferingClientHttpRequest
 extends AbstractClientHttpRequest
org.springframework.http.client.AbstractBufferingClientHttpRequest
@Override protected ClientHttpResponse executeInternal(HttpHeaders headers)
{
    byte[] bytes = this.bufferedOutput.toByteArray();
    if (headers.getContentLength() < 0) {
        headers.setContentLength(bytes.length);
    } 
    ClientHttpResponse result = executeInternal(headers, bytes);
    this.bufferedOutput = new ByteArrayOutputStream(0);
    return result;
}
org.springframework.http.client.AbstractBufferingClientHttpRequest
protected abstract ClientHttpResponse executeInternal(HttpHeaders headers, byte[] bufferedOutput)
org.springframework.http.client.AbstractBufferingClientHttpRequest
@Override protected OutputStream getBodyInternal(HttpHeaders headers)
{
    return this.bufferedOutput;
}
 AbstractClientHttpRequest
 implements ClientHttpRequest
org.springframework.http.client.AbstractClientHttpRequest
protected void assertNotExecuted()
{
    Assert.state(!this.executed, "ClientHttpRequest already executed");
}
org.springframework.http.client.AbstractClientHttpRequest
@Override public final ClientHttpResponse execute()
{
    assertNotExecuted();
    ClientHttpResponse result = executeInternal(this.headers);
    this.executed = true;
    return result;
}
org.springframework.http.client.AbstractClientHttpRequest
protected abstract ClientHttpResponse executeInternal(HttpHeaders headers)
org.springframework.http.client.AbstractClientHttpRequest
@Override public final OutputStream getBody()
{
    assertNotExecuted();
    return getBodyInternal(this.headers);
}
org.springframework.http.client.AbstractClientHttpRequest
protected abstract OutputStream getBodyInternal(HttpHeaders headers)
org.springframework.http.client.AbstractClientHttpRequest
@Override public final HttpHeaders getHeaders()
{
    return (this.executed ? HttpHeaders.readOnlyHttpHeaders(this.headers) : this.headers);
}
 AbstractClientHttpRequestFactoryWrapper
 implements ClientHttpRequestFactory
org.springframework.http.client.AbstractClientHttpRequestFactoryWrapper
protected AbstractClientHttpRequestFactoryWrapper AbstractClientHttpRequestFactoryWrapper(ClientHttpRequestFactory requestFactory)
{
    Assert.notNull(requestFactory, "ClientHttpRequestFactory must not be null");
    this.requestFactory = requestFactory;
}
org.springframework.http.client.AbstractClientHttpRequestFactoryWrapper
@Override public final ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod)
{
    return createRequest(uri, httpMethod, this.requestFactory);
}
org.springframework.http.client.AbstractClientHttpRequestFactoryWrapper
protected abstract ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod, ClientHttpRequestFactory requestFactory)
 AbstractClientHttpResponse
 implements ClientHttpResponse
org.springframework.http.client.AbstractClientHttpResponse
@Override public HttpStatus getStatusCode()
{
    return HttpStatus.valueOf(getRawStatusCode());
}
 AsyncClientHttpRequest
inherit classes
  • HttpRequest
  • HttpOutputMessage
 AsyncClientHttpRequestExecution
 AsyncClientHttpRequestFactory
 AsyncClientHttpRequestInterceptor
 BufferingClientHttpRequestFactory
 extends AbstractClientHttpRequestFactoryWrapper
org.springframework.http.client.BufferingClientHttpRequestFactory
public BufferingClientHttpRequestFactory BufferingClientHttpRequestFactory(ClientHttpRequestFactory requestFactory)
{
    super(requestFactory);
}
org.springframework.http.client.BufferingClientHttpRequestFactory
@Override protected ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod, ClientHttpRequestFactory requestFactory)
{
    ClientHttpRequest request = requestFactory.createRequest(uri, httpMethod);
    if (shouldBuffer(uri, httpMethod)) {
        return new BufferingClientHttpRequestWrapper(request);
    } else {
        return request;
    }
}
org.springframework.http.client.BufferingClientHttpRequestFactory
protected boolean shouldBuffer(URI uri, HttpMethod httpMethod)
{
    return true;
}
 BufferingClientHttpRequestWrapper
 extends AbstractBufferingClientHttpRequest
org.springframework.http.client.BufferingClientHttpRequestWrapper
@Override protected ClientHttpResponse executeInternal(HttpHeaders headers, byte[] bufferedOutput)
{
    this.request.getHeaders().putAll(headers);
    StreamUtils.copy(bufferedOutput, this.request.getBody());
    ClientHttpResponse response = this.request.execute();
    return new BufferingClientHttpResponseWrapper(response);
}
org.springframework.http.client.BufferingClientHttpRequestWrapper
@Override @Nullable public HttpMethod getMethod()
{
    return this.request.getMethod();
}
org.springframework.http.client.BufferingClientHttpRequestWrapper
@Override public String getMethodValue()
{
    return this.request.getMethodValue();
}
org.springframework.http.client.BufferingClientHttpRequestWrapper
@Override public URI getURI()
{
    return this.request.getURI();
}
 BufferingClientHttpResponseWrapper
 implements ClientHttpResponse
org.springframework.http.client.BufferingClientHttpResponseWrapper
@Override public void close()
{
    this.response.close();
}
org.springframework.http.client.BufferingClientHttpResponseWrapper
@Override public InputStream getBody()
{
    if (this.body == null) {
        this.body = StreamUtils.copyToByteArray(this.response.getBody());
    } 
    return new ByteArrayInputStream(this.body);
}
org.springframework.http.client.BufferingClientHttpResponseWrapper
@Override public HttpHeaders getHeaders()
{
    return this.response.getHeaders();
}
org.springframework.http.client.BufferingClientHttpResponseWrapper
@Override public int getRawStatusCode()
{
    return this.response.getRawStatusCode();
}
org.springframework.http.client.BufferingClientHttpResponseWrapper
@Override public HttpStatus getStatusCode()
{
    return this.response.getStatusCode();
}
org.springframework.http.client.BufferingClientHttpResponseWrapper
@Override public String getStatusText()
{
    return this.response.getStatusText();
}
 ClientHttpRequest
inherit classes
  • HttpRequest
  • HttpOutputMessage
 ClientHttpRequestExecution
 ClientHttpRequestFactory
 ClientHttpRequestInitializer
 ClientHttpRequestInterceptor
 ClientHttpResponse
inherit classes
  • HttpInputMessage
  • Closeable
 HttpComponentsAsyncClientHttpRequest
 extends AbstractBufferingAsyncClientHttpRequest
org.springframework.http.client.HttpComponentsAsyncClientHttpRequest
@Override protected ListenableFuture<ClientHttpResponse> executeInternal(HttpHeaders headers, byte[] bufferedOutput)
{
    HttpComponentsClientHttpRequest.addHeaders(this.httpRequest, headers);
    if (this.httpRequest instanceof HttpEntityEnclosingRequest) {
        HttpEntityEnclosingRequest entityEnclosingRequest = (HttpEntityEnclosingRequest)this.httpRequest;
        HttpEntity requestEntity = new NByteArrayEntity(bufferedOutput);
        entityEnclosingRequest.setEntity(requestEntity);
    } 
    HttpResponseFutureCallback callback = new HttpResponseFutureCallback(this.httpRequest);
    Future<HttpResponse> futureResponse = this.httpClient.execute(this.httpRequest, this.httpContext, callback);
    return new ClientHttpResponseFuture(futureResponse, callback);
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequest
@Override public String getMethodValue()
{
    return this.httpRequest.getMethod();
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequest
@Override public URI getURI()
{
    return this.httpRequest.getURI();
}
 HttpComponentsAsyncClientHttpRequestFactory
 extends HttpComponentsClientHttpRequestFactory implements AsyncClientHttpRequestFactory, InitializingBean
org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory
public HttpComponentsAsyncClientHttpRequestFactory HttpComponentsAsyncClientHttpRequestFactory()
{
    super();
    this.asyncClient = HttpAsyncClients.createSystem();
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory
public HttpComponentsAsyncClientHttpRequestFactory HttpComponentsAsyncClientHttpRequestFactory(HttpAsyncClient asyncClient)
{
    super();
    this.asyncClient = asyncClient;
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory
public HttpComponentsAsyncClientHttpRequestFactory HttpComponentsAsyncClientHttpRequestFactory(CloseableHttpAsyncClient asyncClient)
{
    super();
    this.asyncClient = asyncClient;
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory
public HttpComponentsAsyncClientHttpRequestFactory HttpComponentsAsyncClientHttpRequestFactory(HttpClient httpClient, HttpAsyncClient asyncClient)
{
    super(httpClient);
    this.asyncClient = asyncClient;
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory
public HttpComponentsAsyncClientHttpRequestFactory HttpComponentsAsyncClientHttpRequestFactory(CloseableHttpClient httpClient, CloseableHttpAsyncClient asyncClient)
{
    super(httpClient);
    this.asyncClient = asyncClient;
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory
@Override public void afterPropertiesSet()
{
    startAsyncClient();
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory
@Override public AsyncClientHttpRequest createAsyncRequest(URI uri, HttpMethod httpMethod)
{
    HttpAsyncClient client = startAsyncClient();
    HttpUriRequest httpRequest = createHttpUriRequest(httpMethod, uri);
    postProcessHttpRequest(httpRequest);
    HttpContext context = createHttpContext(httpMethod, uri);
    if (context == null) {
        context = HttpClientContext.create();
    } 
    if (context.getAttribute(HttpClientContext.REQUEST_CONFIG) == null) {
        RequestConfig config = null;
        if (httpRequest instanceof Configurable) {
            config = ((Configurable)httpRequest).getConfig();
        } 
        if (config == null) {
            config = createRequestConfig(client);
        } 
        if (config != null) {
            context.setAttribute(HttpClientContext.REQUEST_CONFIG, config);
        } 
    } 
    return new HttpComponentsAsyncClientHttpRequest(client, httpRequest, context);
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory
@Override public void destroy()
{
    try {
        super.destroy();
    } finally {
        HttpAsyncClient asyncClient = getAsyncClient();
        if (asyncClient instanceof Closeable) {
            ((Closeable)asyncClient).close();
        } 
    }
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory
public HttpAsyncClient getAsyncClient()
{
    return this.asyncClient;
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory
@Deprecated public CloseableHttpAsyncClient getHttpAsyncClient()
{
    Assert.state(this.asyncClient instanceof CloseableHttpAsyncClient, "No CloseableHttpAsyncClient - use getAsyncClient() instead");
    return (CloseableHttpAsyncClient)this.asyncClient;
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory
public void setAsyncClient(HttpAsyncClient asyncClient)
{
    Assert.notNull(asyncClient, "HttpAsyncClient must not be null");
    this.asyncClient = asyncClient;
}
org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory
@Deprecated public void setHttpAsyncClient(CloseableHttpAsyncClient asyncClient)
{
    this.asyncClient = asyncClient;
}
 HttpComponentsAsyncClientHttpResponse
 extends AbstractClientHttpResponse
org.springframework.http.client.HttpComponentsAsyncClientHttpResponse
@Override public void close()
{
}
org.springframework.http.client.HttpComponentsAsyncClientHttpResponse
@Override public InputStream getBody()
{
    HttpEntity entity = this.httpResponse.getEntity();
    return (entity != null ? entity.getContent() : StreamUtils.emptyInput());
}
org.springframework.http.client.HttpComponentsAsyncClientHttpResponse
@Override public HttpHeaders getHeaders()
{
    if (this.headers == null) {
        this.headers = new HttpHeaders();
        for (Header header: this.httpResponse.getAllHeaders()) {
            this.headers.add(header.getName(), header.getValue());
        }
    } 
    return this.headers;
}
org.springframework.http.client.HttpComponentsAsyncClientHttpResponse
@Override public int getRawStatusCode()
{
    return this.httpResponse.getStatusLine().getStatusCode();
}
org.springframework.http.client.HttpComponentsAsyncClientHttpResponse
@Override public String getStatusText()
{
    return this.httpResponse.getStatusLine().getReasonPhrase();
}
 HttpComponentsClientHttpRequest
 extends AbstractBufferingClientHttpRequest
org.springframework.http.client.HttpComponentsClientHttpRequest
@Override protected ClientHttpResponse executeInternal(HttpHeaders headers, byte[] bufferedOutput)
{
    addHeaders(this.httpRequest, headers);
    if (this.httpRequest instanceof HttpEntityEnclosingRequest) {
        HttpEntityEnclosingRequest entityEnclosingRequest = (HttpEntityEnclosingRequest)this.httpRequest;
        HttpEntity requestEntity = new ByteArrayEntity(bufferedOutput);
        entityEnclosingRequest.setEntity(requestEntity);
    } 
    HttpResponse httpResponse = this.httpClient.execute(this.httpRequest, this.httpContext);
    return new HttpComponentsClientHttpResponse(httpResponse);
}
org.springframework.http.client.HttpComponentsClientHttpRequest
@Override public String getMethodValue()
{
    return this.httpRequest.getMethod();
}
org.springframework.http.client.HttpComponentsClientHttpRequest
@Override public URI getURI()
{
    return this.httpRequest.getURI();
}
 HttpComponentsClientHttpRequestFactory
 implements ClientHttpRequestFactory, DisposableBean
org.springframework.http.client.HttpComponentsClientHttpRequestFactory
public HttpComponentsClientHttpRequestFactory HttpComponentsClientHttpRequestFactory()
{
    this.httpClient = HttpClients.createSystem();
}
org.springframework.http.client.HttpComponentsClientHttpRequestFactory
public HttpComponentsClientHttpRequestFactory HttpComponentsClientHttpRequestFactory(HttpClient httpClient)
{
    this.httpClient = httpClient;
}
org.springframework.http.client.HttpComponentsClientHttpRequestFactory
@Nullable protected HttpContext createHttpContext(HttpMethod httpMethod, URI uri)
{
    return null;
}
org.springframework.http.client.HttpComponentsClientHttpRequestFactory
@Nullable protected RequestConfig createRequestConfig(Object client)
{
    if (client instanceof Configurable) {
        RequestConfig clientRequestConfig = ((Configurable)client).getConfig();
        return mergeRequestConfig(clientRequestConfig);
    } 
    return this.requestConfig;
}
org.springframework.http.client.HttpComponentsClientHttpRequestFactory
@Override public void destroy()
{
    HttpClient httpClient = getHttpClient();
    if (httpClient instanceof Closeable) {
        ((Closeable)httpClient).close();
    } 
}
org.springframework.http.client.HttpComponentsClientHttpRequestFactory
public HttpClient getHttpClient()
{
    return this.httpClient;
}
org.springframework.http.client.HttpComponentsClientHttpRequestFactory
protected RequestConfig mergeRequestConfig(RequestConfig clientConfig)
{
    if (this.requestConfig == null) {
        return clientConfig;
    } 
    RequestConfig.Builder builder = RequestConfig.copy(clientConfig);
    int connectTimeout = this.requestConfig.getConnectTimeout();
    if (connectTimeout >= 0) {
        builder.setConnectTimeout(connectTimeout);
    } 
    int connectionRequestTimeout = this.requestConfig.getConnectionRequestTimeout();
    if (connectionRequestTimeout >= 0) {
        builder.setConnectionRequestTimeout(connectionRequestTimeout);
    } 
    int socketTimeout = this.requestConfig.getSocketTimeout();
    if (socketTimeout >= 0) {
        builder.setSocketTimeout(socketTimeout);
    } 
    return builder.build();
}
org.springframework.http.client.HttpComponentsClientHttpRequestFactory
protected void postProcessHttpRequest(HttpUriRequest request)
{
}
org.springframework.http.client.HttpComponentsClientHttpRequestFactory
public void setBufferRequestBody(boolean bufferRequestBody)
{
    this.bufferRequestBody = bufferRequestBody;
}
org.springframework.http.client.HttpComponentsClientHttpRequestFactory
public void setConnectTimeout(int timeout)
{
    Assert.isTrue(timeout >= 0, "Timeout must be a non-negative value");
    this.requestConfig = requestConfigBuilder().setConnectTimeout(timeout).build();
}
org.springframework.http.client.HttpComponentsClientHttpRequestFactory
public void setConnectionRequestTimeout(int connectionRequestTimeout)
{
    this.requestConfig = requestConfigBuilder().setConnectionRequestTimeout(connectionRequestTimeout).build();
}
org.springframework.http.client.HttpComponentsClientHttpRequestFactory
public void setHttpClient(HttpClient httpClient)
{
    Assert.notNull(httpClient, "HttpClient must not be null");
    this.httpClient = httpClient;
}
org.springframework.http.client.HttpComponentsClientHttpRequestFactory
public void setReadTimeout(int timeout)
{
    Assert.isTrue(timeout >= 0, "Timeout must be a non-negative value");
    this.requestConfig = requestConfigBuilder().setSocketTimeout(timeout).build();
}
 HttpComponentsClientHttpResponse
 extends AbstractClientHttpResponse
org.springframework.http.client.HttpComponentsClientHttpResponse
@Override public void close()
{
    try {
        try {
            EntityUtils.consume(this.httpResponse.getEntity());
        } finally {
            if (this.httpResponse instanceof Closeable) {
                ((Closeable)this.httpResponse).close();
            } 
        }
    } catch (IOException ex) {
    }
}
org.springframework.http.client.HttpComponentsClientHttpResponse
@Override public InputStream getBody()
{
    HttpEntity entity = this.httpResponse.getEntity();
    return (entity != null ? entity.getContent() : StreamUtils.emptyInput());
}
org.springframework.http.client.HttpComponentsClientHttpResponse
@Override public HttpHeaders getHeaders()
{
    if (this.headers == null) {
        this.headers = new HttpHeaders();
        for (Header header: this.httpResponse.getAllHeaders()) {
            this.headers.add(header.getName(), header.getValue());
        }
    } 
    return this.headers;
}
org.springframework.http.client.HttpComponentsClientHttpResponse
@Override public int getRawStatusCode()
{
    return this.httpResponse.getStatusLine().getStatusCode();
}
org.springframework.http.client.HttpComponentsClientHttpResponse
@Override public String getStatusText()
{
    return this.httpResponse.getStatusLine().getReasonPhrase();
}
 HttpComponentsStreamingClientHttpRequest
 extends AbstractClientHttpRequest implements StreamingHttpOutputMessage
org.springframework.http.client.HttpComponentsStreamingClientHttpRequest
@Override protected ClientHttpResponse executeInternal(HttpHeaders headers)
{
    HttpComponentsClientHttpRequest.addHeaders(this.httpRequest, headers);
    if (this.httpRequest instanceof HttpEntityEnclosingRequest && this.body != null) {
        HttpEntityEnclosingRequest entityEnclosingRequest = (HttpEntityEnclosingRequest)this.httpRequest;
        HttpEntity requestEntity = new StreamingHttpEntity(getHeaders(), this.body);
        entityEnclosingRequest.setEntity(requestEntity);
    } 
    HttpResponse httpResponse = this.httpClient.execute(this.httpRequest, this.httpContext);
    return new HttpComponentsClientHttpResponse(httpResponse);
}
org.springframework.http.client.HttpComponentsStreamingClientHttpRequest
@Override protected OutputStream getBodyInternal(HttpHeaders headers)
{
    throw new UnsupportedOperationException("getBody not supported");
}
org.springframework.http.client.HttpComponentsStreamingClientHttpRequest
@Override public String getMethodValue()
{
    return this.httpRequest.getMethod();
}
org.springframework.http.client.HttpComponentsStreamingClientHttpRequest
@Override public URI getURI()
{
    return this.httpRequest.getURI();
}
org.springframework.http.client.HttpComponentsStreamingClientHttpRequest
@Override public void setBody(Body body)
{
    assertNotExecuted();
    this.body = body;
}
 InterceptingAsyncClientHttpRequest
 extends AbstractBufferingAsyncClientHttpRequest
org.springframework.http.client.InterceptingAsyncClientHttpRequest
public InterceptingAsyncClientHttpRequest InterceptingAsyncClientHttpRequest(AsyncClientHttpRequestFactory requestFactory, List<AsyncClientHttpRequestInterceptor> interceptors, URI uri, HttpMethod httpMethod)
{
    this.requestFactory = requestFactory;
    this.interceptors = interceptors;
    this.uri = uri;
    this.httpMethod = httpMethod;
}
org.springframework.http.client.InterceptingAsyncClientHttpRequest
@Override protected ListenableFuture<ClientHttpResponse> executeInternal(HttpHeaders headers, byte[] body)
{
    return new AsyncRequestExecution().executeAsync(this, body);
}
org.springframework.http.client.InterceptingAsyncClientHttpRequest
@Override public HttpMethod getMethod()
{
    return this.httpMethod;
}
org.springframework.http.client.InterceptingAsyncClientHttpRequest
@Override public String getMethodValue()
{
    return this.httpMethod.name();
}
org.springframework.http.client.InterceptingAsyncClientHttpRequest
@Override public URI getURI()
{
    return this.uri;
}
 InterceptingAsyncClientHttpRequestFactory
 implements AsyncClientHttpRequestFactory
org.springframework.http.client.InterceptingAsyncClientHttpRequestFactory
public InterceptingAsyncClientHttpRequestFactory InterceptingAsyncClientHttpRequestFactory(AsyncClientHttpRequestFactory delegate, @Nullable List<AsyncClientHttpRequestInterceptor> interceptors)
{
    this.delegate = delegate;
    this.interceptors = (interceptors != null ? interceptors : Collections.emptyList());
}
org.springframework.http.client.InterceptingAsyncClientHttpRequestFactory
@Override public AsyncClientHttpRequest createAsyncRequest(URI uri, HttpMethod method)
{
    return new InterceptingAsyncClientHttpRequest(this.delegate, this.interceptors, uri, method);
}
 InterceptingClientHttpRequest
 extends AbstractBufferingClientHttpRequest
org.springframework.http.client.InterceptingClientHttpRequest
protected InterceptingClientHttpRequest InterceptingClientHttpRequest(ClientHttpRequestFactory requestFactory, List<ClientHttpRequestInterceptor> interceptors, URI uri, HttpMethod method)
{
    this.requestFactory = requestFactory;
    this.interceptors = interceptors;
    this.method = method;
    this.uri = uri;
}
org.springframework.http.client.InterceptingClientHttpRequest
@Override protected final ClientHttpResponse executeInternal(HttpHeaders headers, byte[] bufferedOutput)
{
    InterceptingRequestExecution requestExecution = new InterceptingRequestExecution();
    return requestExecution.execute(this, bufferedOutput);
}
org.springframework.http.client.InterceptingClientHttpRequest
@Override public HttpMethod getMethod()
{
    return this.method;
}
org.springframework.http.client.InterceptingClientHttpRequest
@Override public String getMethodValue()
{
    return this.method.name();
}
org.springframework.http.client.InterceptingClientHttpRequest
@Override public URI getURI()
{
    return this.uri;
}
 InterceptingClientHttpRequestFactory
 extends AbstractClientHttpRequestFactoryWrapper
org.springframework.http.client.InterceptingClientHttpRequestFactory
public InterceptingClientHttpRequestFactory InterceptingClientHttpRequestFactory(ClientHttpRequestFactory requestFactory, @Nullable List<ClientHttpRequestInterceptor> interceptors)
{
    super(requestFactory);
    this.interceptors = (interceptors != null ? interceptors : Collections.emptyList());
}
org.springframework.http.client.InterceptingClientHttpRequestFactory
@Override protected ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod, ClientHttpRequestFactory requestFactory)
{
    return new InterceptingClientHttpRequest(requestFactory, this.interceptors, uri, httpMethod);
}
 MultipartBodyBuilder
org.springframework.http.client.MultipartBodyBuilder
public MultipartBodyBuilder MultipartBodyBuilder()
{
}
 PartBuilder
org.springframework.http.client.MultipartBodyBuilder
public PartBuilder part(String name, Object part)
{
    return part(name, part, null);
}
 Netty4ClientHttpRequest
 extends AbstractAsyncClientHttpRequest implements ClientHttpRequest
org.springframework.http.client.Netty4ClientHttpRequest
public Netty4ClientHttpRequest Netty4ClientHttpRequest(Bootstrap bootstrap, URI uri, HttpMethod method)
{
    this.bootstrap = bootstrap;
    this.uri = uri;
    this.method = method;
    this.body = new ByteBufOutputStream(Unpooled.buffer(1024));
}
org.springframework.http.client.Netty4ClientHttpRequest
@Override protected OutputStream getBodyInternal(HttpHeaders headers)
{
    return this.body;
}
org.springframework.http.client.Netty4ClientHttpRequest
@Override public HttpMethod getMethod()
{
    return this.method;
}
org.springframework.http.client.Netty4ClientHttpRequest
@Override public String getMethodValue()
{
    return this.method.name();
}
org.springframework.http.client.Netty4ClientHttpRequest
@Override public URI getURI()
{
    return this.uri;
}
 Netty4ClientHttpRequestFactory
 implements ClientHttpRequestFactory, AsyncClientHttpRequestFactory, InitializingBean, DisposableBean
org.springframework.http.client.Netty4ClientHttpRequestFactory
public static final int DEFAULT_MAX_RESPONSE_SIZE
org.springframework.http.client.Netty4ClientHttpRequestFactory
public Netty4ClientHttpRequestFactory Netty4ClientHttpRequestFactory()
{
    int ioWorkerCount = Runtime.getRuntime().availableProcessors() * 2;
    this.eventLoopGroup = new NioEventLoopGroup(ioWorkerCount);
    this.defaultEventLoopGroup = true;
}
org.springframework.http.client.Netty4ClientHttpRequestFactory
public Netty4ClientHttpRequestFactory Netty4ClientHttpRequestFactory(EventLoopGroup eventLoopGroup)
{
    Assert.notNull(eventLoopGroup, "EventLoopGroup must not be null");
    this.eventLoopGroup = eventLoopGroup;
    this.defaultEventLoopGroup = false;
}
org.springframework.http.client.Netty4ClientHttpRequestFactory
@Override public void afterPropertiesSet()
{
    if (this.sslContext == null) {
        this.sslContext = getDefaultClientSslContext();
    } 
}
org.springframework.http.client.Netty4ClientHttpRequestFactory
@Nullable volatile Bootstrap bootstrap
org.springframework.http.client.Netty4ClientHttpRequestFactory
protected void configureChannel(SocketChannelConfig config)
{
    if (this.connectTimeout >= 0) {
        config.setConnectTimeoutMillis(this.connectTimeout);
    } 
}
org.springframework.http.client.Netty4ClientHttpRequestFactory
@Override public AsyncClientHttpRequest createAsyncRequest(URI uri, HttpMethod httpMethod)
{
    return createRequestInternal(uri, httpMethod);
}
org.springframework.http.client.Netty4ClientHttpRequestFactory
@Override public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod)
{
    return createRequestInternal(uri, httpMethod);
}
org.springframework.http.client.Netty4ClientHttpRequestFactory
@Override public void destroy()
{
    if (this.defaultEventLoopGroup) {
        this.eventLoopGroup.shutdownGracefully().sync();
    } 
}
org.springframework.http.client.Netty4ClientHttpRequestFactory
public void setConnectTimeout(int connectTimeout)
{
    this.connectTimeout = connectTimeout;
}
org.springframework.http.client.Netty4ClientHttpRequestFactory
public void setMaxResponseSize(int maxResponseSize)
{
    this.maxResponseSize = maxResponseSize;
}
org.springframework.http.client.Netty4ClientHttpRequestFactory
public void setReadTimeout(int readTimeout)
{
    this.readTimeout = readTimeout;
}
org.springframework.http.client.Netty4ClientHttpRequestFactory
public void setSslContext(SslContext sslContext)
{
    this.sslContext = sslContext;
}
 Netty4ClientHttpResponse
 extends AbstractClientHttpResponse
org.springframework.http.client.Netty4ClientHttpResponse
@Override public void close()
{
    this.nettyResponse.release();
    this.context.close();
}
org.springframework.http.client.Netty4ClientHttpResponse
@Override public InputStream getBody()
{
    return this.body;
}
org.springframework.http.client.Netty4ClientHttpResponse
@Override public HttpHeaders getHeaders()
{
    HttpHeaders headers = this.headers;
    if (headers == null) {
        headers = new HttpHeaders();
        for (Map.Entry<String, String> entry: this.nettyResponse.headers()) {
            headers.add(entry.getKey(), entry.getValue());
        }
        this.headers = headers;
    } 
    return headers;
}
org.springframework.http.client.Netty4ClientHttpResponse
@Override public int getRawStatusCode()
{
    return this.nettyResponse.getStatus().code();
}
org.springframework.http.client.Netty4ClientHttpResponse
@Override public String getStatusText()
{
    return this.nettyResponse.getStatus().reasonPhrase();
}
org.springframework.http.client.Netty4ClientHttpResponse
@Nullable volatile HttpHeaders headers
 OkHttp3AsyncClientHttpRequest
 extends AbstractBufferingAsyncClientHttpRequest
org.springframework.http.client.OkHttp3AsyncClientHttpRequest
public OkHttp3AsyncClientHttpRequest OkHttp3AsyncClientHttpRequest(OkHttpClient client, URI uri, HttpMethod method)
{
    this.client = client;
    this.uri = uri;
    this.method = method;
}
org.springframework.http.client.OkHttp3AsyncClientHttpRequest
@Override protected ListenableFuture<ClientHttpResponse> executeInternal(HttpHeaders headers, byte[] content)
{
    Request request = OkHttp3ClientHttpRequestFactory.buildRequest(headers, content, this.uri, this.method);
    return new OkHttpListenableFuture(this.client.newCall(request));
}
org.springframework.http.client.OkHttp3AsyncClientHttpRequest
@Override public HttpMethod getMethod()
{
    return this.method;
}
org.springframework.http.client.OkHttp3AsyncClientHttpRequest
@Override public String getMethodValue()
{
    return this.method.name();
}
org.springframework.http.client.OkHttp3AsyncClientHttpRequest
@Override public URI getURI()
{
    return this.uri;
}
 OkHttp3ClientHttpRequest
 extends AbstractBufferingClientHttpRequest
org.springframework.http.client.OkHttp3ClientHttpRequest
public OkHttp3ClientHttpRequest OkHttp3ClientHttpRequest(OkHttpClient client, URI uri, HttpMethod method)
{
    this.client = client;
    this.uri = uri;
    this.method = method;
}
org.springframework.http.client.OkHttp3ClientHttpRequest
@Override protected ClientHttpResponse executeInternal(HttpHeaders headers, byte[] content)
{
    Request request = OkHttp3ClientHttpRequestFactory.buildRequest(headers, content, this.uri, this.method);
    return new OkHttp3ClientHttpResponse(this.client.newCall(request).execute());
}
org.springframework.http.client.OkHttp3ClientHttpRequest
@Override public HttpMethod getMethod()
{
    return this.method;
}
org.springframework.http.client.OkHttp3ClientHttpRequest
@Override public String getMethodValue()
{
    return this.method.name();
}
org.springframework.http.client.OkHttp3ClientHttpRequest
@Override public URI getURI()
{
    return this.uri;
}
 OkHttp3ClientHttpRequestFactory
 implements ClientHttpRequestFactory, AsyncClientHttpRequestFactory, DisposableBean
org.springframework.http.client.OkHttp3ClientHttpRequestFactory
public OkHttp3ClientHttpRequestFactory OkHttp3ClientHttpRequestFactory()
{
    this.client = new OkHttpClient();
    this.defaultClient = true;
}
org.springframework.http.client.OkHttp3ClientHttpRequestFactory
public OkHttp3ClientHttpRequestFactory OkHttp3ClientHttpRequestFactory(OkHttpClient client)
{
    Assert.notNull(client, "OkHttpClient must not be null");
    this.client = client;
    this.defaultClient = false;
}
org.springframework.http.client.OkHttp3ClientHttpRequestFactory
@Override public AsyncClientHttpRequest createAsyncRequest(URI uri, HttpMethod httpMethod)
{
    return new OkHttp3AsyncClientHttpRequest(this.client, uri, httpMethod);
}
org.springframework.http.client.OkHttp3ClientHttpRequestFactory
@Override public ClientHttpRequest createRequest(URI uri, HttpMethod httpMethod)
{
    return new OkHttp3ClientHttpRequest(this.client, uri, httpMethod);
}
org.springframework.http.client.OkHttp3ClientHttpRequestFactory
@Override public void destroy()
{
    if (this.defaultClient) {
        Cache cache = this.client.cache();
        if (cache != null) {
            cache.close();
        } 
        this.client.dispatcher().executorService().shutdown();
    } 
}
org.springframework.http.client.OkHttp3ClientHttpRequestFactory
public void setConnectTimeout(int connectTimeout)
{
    this.client = this.client.newBuilder().connectTimeout(connectTimeout, TimeUnit.MILLISECONDS).build();
}
org.springframework.http.client.OkHttp3ClientHttpRequestFactory
public void setReadTimeout(int readTimeout)
{
    this.client = this.client.newBuilder().readTimeout(readTimeout, TimeUnit.MILLISECONDS).build();
}
org.springframework.http.client.OkHttp3ClientHttpRequestFactory
public void setWriteTimeout(int writeTimeout)
{
    this.client = this.client.newBuilder().writeTimeout(writeTimeout, TimeUnit.MILLISECONDS).build();
}
 OkHttp3ClientHttpResponse
 extends AbstractClientHttpResponse
org.springframework.http.client.OkHttp3ClientHttpResponse
public OkHttp3ClientHttpResponse OkHttp3ClientHttpResponse(Response response)
{
    Assert.notNull(response, "Response must not be null");
    this.response = response;
}
org.springframework.http.client.OkHttp3ClientHttpResponse
@Override public void close()
{
    ResponseBody body = this.response.body();
    if (body != null) {
        body.close();
    } 
}
org.springframework.http.client.OkHttp3ClientHttpResponse
@Override public InputStream getBody()
{
    ResponseBody body = this.response.body();
    return (body != null ? body.byteStream() : StreamUtils.emptyInput());
}
org.springframework.http.client.OkHttp3ClientHttpResponse
@Override public int getRawStatusCode()
{
    return this.response.code();
}
org.springframework.http.client.OkHttp3ClientHttpResponse
@Override public String getStatusText()
{
    return this.response.message();
}
org.springframework.http.client.OkHttp3ClientHttpResponse
@Nullable volatile HttpHeaders headers
 SimpleBufferingAsyncClientHttpRequest
 extends AbstractBufferingAsyncClientHttpRequest
org.springframework.http.client.SimpleBufferingAsyncClientHttpRequest
@Override protected ListenableFuture<ClientHttpResponse> executeInternal(final HttpHeaders headers, final byte[] bufferedOutput)
{
    return this.taskExecutor.submitListenable(new Callable<ClientHttpResponse>() {
        @Override
        public ClientHttpResponse call() throws Exception{
            SimpleBufferingClientHttpRequest.addHeaders(connection, headers);
            if (getMethod() == HttpMethod.DELETE && bufferedOutput.length == 0) {
                connection.setDoOutput(false);
            } 
            if (connection.getDoOutput() && outputStreaming) {
                connection.setFixedLengthStreamingMode(bufferedOutput.length);
            } 
            connection.connect();
            if (connection.getDoOutput()) {
                FileCopyUtils.copy(bufferedOutput, connection.getOutputStream());
            } else {
                connection.getResponseCode();
            }
            return new SimpleClientHttpResponse(connection);
        }
    });
}
org.springframework.http.client.SimpleBufferingAsyncClientHttpRequest
@Override public String getMethodValue()
{
    return this.connection.getRequestMethod();
}
org.springframework.http.client.SimpleBufferingAsyncClientHttpRequest
@Override public URI getURI()
{
    try {
        return this.connection.getURL().toURI();
    } catch (URISyntaxException ex) {
        throw new IllegalStateException("Could not get HttpURLConnection URI: " + ex.getMessage(), ex);
    }
}
 SimpleBufferingClientHttpRequest
 extends AbstractBufferingClientHttpRequest
org.springframework.http.client.SimpleBufferingClientHttpRequest
@Override protected ClientHttpResponse executeInternal(HttpHeaders headers, byte[] bufferedOutput)
{
    addHeaders(this.connection, headers);
    if (getMethod() == HttpMethod.DELETE && bufferedOutput.length == 0) {
        this.connection.setDoOutput(false);
    } 
    if (this.connection.getDoOutput() && this.outputStreaming) {
        this.connection.setFixedLengthStreamingMode(bufferedOutput.length);
    } 
    this.connection.connect();
    if (this.connection.getDoOutput()) {
        FileCopyUtils.copy(bufferedOutput, this.connection.getOutputStream());
    } else {
        this.connection.getResponseCode();
    }
    return new SimpleClientHttpResponse(this.connection);
}
org.springframework.http.client.SimpleBufferingClientHttpRequest
@Override public String getMethodValue()
{
    return this.connection.getRequestMethod();
}
org.springframework.http.client.SimpleBufferingClientHttpRequest
@Override public URI getURI()
{
    try {
        return this.connection.getURL().toURI();
    } catch (URISyntaxException ex) {
        throw new IllegalStateException("Could not get HttpURLConnection URI: " + ex.getMessage(), ex);
    }
}
 SimpleClientHttpRequestFactory
 implements ClientHttpRequestFactory, AsyncClientHttpRequestFactory
org.springframework.http.client.SimpleClientHttpRequestFactory
protected HttpURLConnection openConnection(URL url, @Nullable Proxy proxy)
{
    URLConnection urlConnection = (proxy != null ? url.openConnection(proxy) : url.openConnection());
    if (!HttpURLConnection.class.isInstance(urlConnection)) {
        throw new IllegalStateException("HttpURLConnection required for [" + url + "] but got: " + urlConnection);
    } 
    return (HttpURLConnection)urlConnection;
}
org.springframework.http.client.SimpleClientHttpRequestFactory
protected void prepareConnection(HttpURLConnection connection, String httpMethod)
{
    if (this.connectTimeout >= 0) {
        connection.setConnectTimeout(this.connectTimeout);
    } 
    if (this.readTimeout >= 0) {
        connection.setReadTimeout(this.readTimeout);
    } 
    connection.setDoInput(true);
    if ("GET".equals(httpMethod)) {
        connection.setInstanceFollowRedirects(true);
    } else {
        connection.setInstanceFollowRedirects(false);
    }
    if ("POST".equals(httpMethod) || "PUT".equals(httpMethod) || "PATCH".equals(httpMethod) || "DELETE".equals(httpMethod)) {
        connection.setDoOutput(true);
    } else {
        connection.setDoOutput(false);
    }
    connection.setRequestMethod(httpMethod);
}
org.springframework.http.client.SimpleClientHttpRequestFactory
public void setBufferRequestBody(boolean bufferRequestBody)
{
    this.bufferRequestBody = bufferRequestBody;
}
org.springframework.http.client.SimpleClientHttpRequestFactory
public void setChunkSize(int chunkSize)
{
    this.chunkSize = chunkSize;
}
org.springframework.http.client.SimpleClientHttpRequestFactory
public void setConnectTimeout(int connectTimeout)
{
    this.connectTimeout = connectTimeout;
}
org.springframework.http.client.SimpleClientHttpRequestFactory
public void setOutputStreaming(boolean outputStreaming)
{
    this.outputStreaming = outputStreaming;
}
org.springframework.http.client.SimpleClientHttpRequestFactory
public void setProxy(Proxy proxy)
{
    this.proxy = proxy;
}
org.springframework.http.client.SimpleClientHttpRequestFactory
public void setReadTimeout(int readTimeout)
{
    this.readTimeout = readTimeout;
}
org.springframework.http.client.SimpleClientHttpRequestFactory
public void setTaskExecutor(AsyncListenableTaskExecutor taskExecutor)
{
    this.taskExecutor = taskExecutor;
}
 SimpleClientHttpResponse
 extends AbstractClientHttpResponse
org.springframework.http.client.SimpleClientHttpResponse
@Override public void close()
{
    try {
        if (this.responseStream == null) {
            getBody();
        } 
        StreamUtils.drain(this.responseStream);
        this.responseStream.close();
    } catch (Exception ex) {
    }
}
org.springframework.http.client.SimpleClientHttpResponse
@Override public HttpHeaders getHeaders()
{
    if (this.headers == null) {
        this.headers = new HttpHeaders();
        String name = this.connection.getHeaderFieldKey(0);
        if (StringUtils.hasLength(name)) {
            this.headers.add(name, this.connection.getHeaderField(0));
        } 
        int i = 1;
        while (true) {
            name = this.connection.getHeaderFieldKey(i);
            if (!StringUtils.hasLength(name)) {
                break;
            } 
            this.headers.add(name, this.connection.getHeaderField(i));
            i++;
        }
    } 
    return this.headers;
}
org.springframework.http.client.SimpleClientHttpResponse
@Override public int getRawStatusCode()
{
    return this.connection.getResponseCode();
}
org.springframework.http.client.SimpleClientHttpResponse
@Override public String getStatusText()
{
    String result = this.connection.getResponseMessage();
    return (result != null) ? result : "";
}
 SimpleStreamingAsyncClientHttpRequest
 extends AbstractAsyncClientHttpRequest
org.springframework.http.client.SimpleStreamingAsyncClientHttpRequest
@Override protected ListenableFuture<ClientHttpResponse> executeInternal(final HttpHeaders headers)
{
    return this.taskExecutor.submitListenable(new Callable<ClientHttpResponse>() {
        @Override
        public ClientHttpResponse call() throws Exception{
            try {
                if (body != null) {
                    body.close();
                } else {
                    SimpleBufferingClientHttpRequest.addHeaders(connection, headers);
                    connection.connect();
                    connection.getResponseCode();
                }
            } catch (IOException ex) {
            }
            return new SimpleClientHttpResponse(connection);
        }
    });
}
org.springframework.http.client.SimpleStreamingAsyncClientHttpRequest
@Override protected OutputStream getBodyInternal(HttpHeaders headers)
{
    if (this.body == null) {
        if (this.outputStreaming) {
            long contentLength = headers.getContentLength();
            if (contentLength >= 0) {
                this.connection.setFixedLengthStreamingMode(contentLength);
            } else {
                this.connection.setChunkedStreamingMode(this.chunkSize);
            }
        } 
        SimpleBufferingClientHttpRequest.addHeaders(this.connection, headers);
        this.connection.connect();
        this.body = this.connection.getOutputStream();
    } 
    return StreamUtils.nonClosing(this.body);
}
org.springframework.http.client.SimpleStreamingAsyncClientHttpRequest
@Override public String getMethodValue()
{
    return this.connection.getRequestMethod();
}
org.springframework.http.client.SimpleStreamingAsyncClientHttpRequest
@Override public URI getURI()
{
    try {
        return this.connection.getURL().toURI();
    } catch (URISyntaxException ex) {
        throw new IllegalStateException("Could not get HttpURLConnection URI: " + ex.getMessage(), ex);
    }
}
 SimpleStreamingClientHttpRequest
 extends AbstractClientHttpRequest
org.springframework.http.client.SimpleStreamingClientHttpRequest
@Override protected ClientHttpResponse executeInternal(HttpHeaders headers)
{
    try {
        if (this.body != null) {
            this.body.close();
        } else {
            SimpleBufferingClientHttpRequest.addHeaders(this.connection, headers);
            this.connection.connect();
            this.connection.getResponseCode();
        }
    } catch (IOException ex) {
    }
    return new SimpleClientHttpResponse(this.connection);
}
org.springframework.http.client.SimpleStreamingClientHttpRequest
@Override protected OutputStream getBodyInternal(HttpHeaders headers)
{
    if (this.body == null) {
        if (this.outputStreaming) {
            long contentLength = headers.getContentLength();
            if (contentLength >= 0) {
                this.connection.setFixedLengthStreamingMode(contentLength);
            } else {
                this.connection.setChunkedStreamingMode(this.chunkSize);
            }
        } 
        SimpleBufferingClientHttpRequest.addHeaders(this.connection, headers);
        this.connection.connect();
        this.body = this.connection.getOutputStream();
    } 
    return StreamUtils.nonClosing(this.body);
}
org.springframework.http.client.SimpleStreamingClientHttpRequest
@Override public String getMethodValue()
{
    return this.connection.getRequestMethod();
}
org.springframework.http.client.SimpleStreamingClientHttpRequest
@Override public URI getURI()
{
    try {
        return this.connection.getURL().toURI();
    } catch (URISyntaxException ex) {
        throw new IllegalStateException("Could not get HttpURLConnection URI: " + ex.getMessage(), ex);
    }
}
 AbstractClientHttpRequest
 implements ClientHttpRequest
org.springframework.http.client.reactive.AbstractClientHttpRequest
public AbstractClientHttpRequest AbstractClientHttpRequest()
{
    this(new HttpHeaders());
}
org.springframework.http.client.reactive.AbstractClientHttpRequest
public AbstractClientHttpRequest AbstractClientHttpRequest(HttpHeaders headers)
{
    Assert.notNull(headers, "HttpHeaders must not be null");
    this.headers = headers;
    this.cookies = new LinkedMultiValueMap<>();
}
org.springframework.http.client.reactive.AbstractClientHttpRequest
protected abstract void applyCookies()
org.springframework.http.client.reactive.AbstractClientHttpRequest
protected abstract void applyHeaders()
org.springframework.http.client.reactive.AbstractClientHttpRequest
@Override public void beforeCommit(Supplier<?> action)
{
    Assert.notNull(action, "Action must not be null");
    this.commitActions.add(action);
}
org.springframework.http.client.reactive.AbstractClientHttpRequest
protected Mono<Void> doCommit()
{
    return doCommit(null);
}
org.springframework.http.client.reactive.AbstractClientHttpRequest
protected Mono<Void> doCommit(@Nullable Supplier<?> writeAction)
{
    if (!this.state.compareAndSet(State.NEW, State.COMMITTING)) {
        return Mono.empty();
    } 
    this.commitActions.add(() -> Mono.fromRunnable(() -> {
        applyHeaders();
        applyCookies();
        this.state.set(State.COMMITTED);
    }));
    if (writeAction != null) {
        this.commitActions.add(writeAction);
    } 
    List<? extends Publisher<Void>> actions = this.commitActions.stream().map(Supplier::get).collect(Collectors.toList());
    return Flux.concat(actions).then();
}
org.springframework.http.client.reactive.AbstractClientHttpRequest
@Override public MultiValueMap<String, HttpCookie> getCookies()
{
    if (State.COMMITTED.equals(this.state.get())) {
        return CollectionUtils.unmodifiableMultiValueMap(this.cookies);
    } 
    return this.cookies;
}
org.springframework.http.client.reactive.AbstractClientHttpRequest
@Override public HttpHeaders getHeaders()
{
    if (State.COMMITTED.equals(this.state.get())) {
        return HttpHeaders.readOnlyHttpHeaders(this.headers);
    } 
    return this.headers;
}
org.springframework.http.client.reactive.AbstractClientHttpRequest
@Override public boolean isCommitted()
{
    return (this.state.get() != State.NEW);
}
 ClientHttpConnector
 ClientHttpRequest
inherit classes
  • ReactiveHttpOutputMessage
 ClientHttpRequestDecorator
 implements ClientHttpRequest
org.springframework.http.client.reactive.ClientHttpRequestDecorator
public ClientHttpRequestDecorator ClientHttpRequestDecorator(ClientHttpRequest delegate)
{
    Assert.notNull(delegate, "Delegate is required");
    this.delegate = delegate;
}
org.springframework.http.client.reactive.ClientHttpRequestDecorator
@Override public void beforeCommit(Supplier<?> action)
{
    this.delegate.beforeCommit(action);
}
org.springframework.http.client.reactive.ClientHttpRequestDecorator
@Override public DataBufferFactory bufferFactory()
{
    return this.delegate.bufferFactory();
}
org.springframework.http.client.reactive.ClientHttpRequestDecorator
@Override public MultiValueMap<String, HttpCookie> getCookies()
{
    return this.delegate.getCookies();
}
org.springframework.http.client.reactive.ClientHttpRequestDecorator
public ClientHttpRequest getDelegate()
{
    return this.delegate;
}
org.springframework.http.client.reactive.ClientHttpRequestDecorator
@Override public HttpHeaders getHeaders()
{
    return this.delegate.getHeaders();
}
org.springframework.http.client.reactive.ClientHttpRequestDecorator
@Override public HttpMethod getMethod()
{
    return this.delegate.getMethod();
}
org.springframework.http.client.reactive.ClientHttpRequestDecorator
@Override public URI getURI()
{
    return this.delegate.getURI();
}
org.springframework.http.client.reactive.ClientHttpRequestDecorator
@Override public boolean isCommitted()
{
    return this.delegate.isCommitted();
}
org.springframework.http.client.reactive.ClientHttpRequestDecorator
@Override public Mono<Void> setComplete()
{
    return this.delegate.setComplete();
}
org.springframework.http.client.reactive.ClientHttpRequestDecorator
@Override public String toString()
{
    return getClass().getSimpleName() + " [delegate=" + getDelegate() + "]";
}
org.springframework.http.client.reactive.ClientHttpRequestDecorator
@Override public Mono<Void> writeAndFlushWith(Publisher<?> body)
{
    return this.delegate.writeAndFlushWith(body);
}
org.springframework.http.client.reactive.ClientHttpRequestDecorator
@Override public Mono<Void> writeWith(Publisher<?> body)
{
    return this.delegate.writeWith(body);
}
 ClientHttpResponse
inherit classes
  • ReactiveHttpInputMessage
 ClientHttpResponseDecorator
 implements ClientHttpResponse
org.springframework.http.client.reactive.ClientHttpResponseDecorator
public ClientHttpResponseDecorator ClientHttpResponseDecorator(ClientHttpResponse delegate)
{
    Assert.notNull(delegate, "Delegate is required");
    this.delegate = delegate;
}
org.springframework.http.client.reactive.ClientHttpResponseDecorator
@Override public Flux<DataBuffer> getBody()
{
    return this.delegate.getBody();
}
org.springframework.http.client.reactive.ClientHttpResponseDecorator
@Override public MultiValueMap<String, ResponseCookie> getCookies()
{
    return this.delegate.getCookies();
}
org.springframework.http.client.reactive.ClientHttpResponseDecorator
public ClientHttpResponse getDelegate()
{
    return this.delegate;
}
org.springframework.http.client.reactive.ClientHttpResponseDecorator
@Override public HttpHeaders getHeaders()
{
    return this.delegate.getHeaders();
}
org.springframework.http.client.reactive.ClientHttpResponseDecorator
@Override public int getRawStatusCode()
{
    return this.delegate.getRawStatusCode();
}
org.springframework.http.client.reactive.ClientHttpResponseDecorator
@Override public HttpStatus getStatusCode()
{
    return this.delegate.getStatusCode();
}
org.springframework.http.client.reactive.ClientHttpResponseDecorator
@Override public String toString()
{
    return getClass().getSimpleName() + " [delegate=" + getDelegate() + "]";
}
 JettyClientHttpConnector
 implements ClientHttpConnector
org.springframework.http.client.reactive.JettyClientHttpConnector
public JettyClientHttpConnector JettyClientHttpConnector()
{
    this(new HttpClient());
}
org.springframework.http.client.reactive.JettyClientHttpConnector
public JettyClientHttpConnector JettyClientHttpConnector(HttpClient httpClient)
{
    this(httpClient, null);
}
org.springframework.http.client.reactive.JettyClientHttpConnector
public JettyClientHttpConnector JettyClientHttpConnector(HttpClient httpClient, @Nullable JettyResourceFactory resourceFactory)
{
    Assert.notNull(httpClient, "HttpClient is required");
    if (resourceFactory != null) {
        httpClient.setExecutor(resourceFactory.getExecutor());
        httpClient.setByteBufferPool(resourceFactory.getByteBufferPool());
        httpClient.setScheduler(resourceFactory.getScheduler());
    } 
    this.httpClient = httpClient;
}
org.springframework.http.client.reactive.JettyClientHttpConnector
@Deprecated public JettyClientHttpConnector JettyClientHttpConnector(JettyResourceFactory resourceFactory, @Nullable Consumer<HttpClient> customizer)
{
    this(new HttpClient(), resourceFactory);
    if (customizer != null) {
        customizer.accept(this.httpClient);
    } 
}
org.springframework.http.client.reactive.JettyClientHttpConnector
@Override public Mono<ClientHttpResponse> connect(HttpMethod method, URI uri, Function<?, Mono<Void>> requestCallback)
{
    if (!uri.isAbsolute()) {
        return Mono.error(new IllegalArgumentException("URI is not absolute: " + uri));
    } 
    if (!this.httpClient.isStarted()) {
        try {
            this.httpClient.start();
        } catch (Exception ex) {
            return Mono.error(ex);
        }
    } 
    JettyClientHttpRequest clientHttpRequest = new JettyClientHttpRequest(this.httpClient.newRequest(uri).method(method.toString()), this.bufferFactory);
    return requestCallback.apply(clientHttpRequest).then(Mono.from(clientHttpRequest.getReactiveRequest().response((response, chunks) -> {
        Flux<DataBuffer> content = Flux.from(chunks).map(this::toDataBuffer);
        return Mono.just(new JettyClientHttpResponse(response, content));
    })));
}
org.springframework.http.client.reactive.JettyClientHttpConnector
public void setBufferFactory(DataBufferFactory bufferFactory)
{
    this.bufferFactory = bufferFactory;
}
 JettyClientHttpRequest
 extends AbstractClientHttpRequest
org.springframework.http.client.reactive.JettyClientHttpRequest
public JettyClientHttpRequest JettyClientHttpRequest(Request jettyRequest, DataBufferFactory bufferFactory)
{
    this.jettyRequest = jettyRequest;
    this.bufferFactory = bufferFactory;
}
org.springframework.http.client.reactive.JettyClientHttpRequest
@Override public DataBufferFactory bufferFactory()
{
    return this.bufferFactory;
}
org.springframework.http.client.reactive.JettyClientHttpRequest
@Override public HttpMethod getMethod()
{
    HttpMethod method = HttpMethod.resolve(this.jettyRequest.getMethod());
    Assert.state(method != null, "Method must not be null");
    return method;
}
org.springframework.http.client.reactive.JettyClientHttpRequest
@Override public URI getURI()
{
    return this.jettyRequest.getURI();
}
org.springframework.http.client.reactive.JettyClientHttpRequest
@Override public Mono<Void> setComplete()
{
    return doCommit(this::completes);
}
 JettyClientHttpResponse
 implements ClientHttpResponse
org.springframework.http.client.reactive.JettyClientHttpResponse
public JettyClientHttpResponse JettyClientHttpResponse(ReactiveResponse reactiveResponse, Publisher<DataBuffer> content)
{
    this.reactiveResponse = reactiveResponse;
    this.content = Flux.from(content);
}
org.springframework.http.client.reactive.JettyClientHttpResponse
@Override public Flux<DataBuffer> getBody()
{
    return this.content;
}
org.springframework.http.client.reactive.JettyClientHttpResponse
@Override public int getRawStatusCode()
{
    return this.reactiveResponse.getStatus();
}
org.springframework.http.client.reactive.JettyClientHttpResponse
@Override public HttpStatus getStatusCode()
{
    return HttpStatus.valueOf(getRawStatusCode());
}
 JettyResourceFactory
 implements InitializingBean, DisposableBean
org.springframework.http.client.reactive.JettyResourceFactory
@Override public void destroy()
{
    try {
        if (this.executor instanceof LifeCycle) {
            ((LifeCycle)this.executor).stop();
        } 
    } catch (Throwable ex) {
    }
    try {
        if (this.scheduler != null) {
            this.scheduler.stop();
        } 
    } catch (Throwable ex) {
    }
}
org.springframework.http.client.reactive.JettyResourceFactory
@Nullable public ByteBufferPool getByteBufferPool()
{
    return this.byteBufferPool;
}
org.springframework.http.client.reactive.JettyResourceFactory
@Nullable public Executor getExecutor()
{
    return this.executor;
}
org.springframework.http.client.reactive.JettyResourceFactory
@Nullable public Scheduler getScheduler()
{
    return this.scheduler;
}
org.springframework.http.client.reactive.JettyResourceFactory
public void setByteBufferPool(@Nullable ByteBufferPool byteBufferPool)
{
    this.byteBufferPool = byteBufferPool;
}
org.springframework.http.client.reactive.JettyResourceFactory
public void setExecutor(@Nullable Executor executor)
{
    this.executor = executor;
}
org.springframework.http.client.reactive.JettyResourceFactory
public void setScheduler(@Nullable Scheduler scheduler)
{
    this.scheduler = scheduler;
}
org.springframework.http.client.reactive.JettyResourceFactory
public void setThreadPrefix(String threadPrefix)
{
    Assert.notNull(threadPrefix, "Thread prefix is required");
    this.threadPrefix = threadPrefix;
}
 ReactorClientHttpConnector
 implements ClientHttpConnector
org.springframework.http.client.reactive.ReactorClientHttpConnector
public ReactorClientHttpConnector ReactorClientHttpConnector()
{
    this.httpClient = defaultInitializer.apply(HttpClient.create());
}
org.springframework.http.client.reactive.ReactorClientHttpConnector
public ReactorClientHttpConnector ReactorClientHttpConnector(ReactorResourceFactory factory, Function<HttpClient, HttpClient> mapper)
{
    this.httpClient = defaultInitializer.andThen(mapper).apply(initHttpClient(factory));
}
org.springframework.http.client.reactive.ReactorClientHttpConnector
public ReactorClientHttpConnector ReactorClientHttpConnector(HttpClient httpClient)
{
    Assert.notNull(httpClient, "HttpClient is required");
    this.httpClient = httpClient;
}
org.springframework.http.client.reactive.ReactorClientHttpConnector
@Override public Mono<ClientHttpResponse> connect(HttpMethod method, URI uri, Function<?, Mono<Void>> requestCallback)
{
    if (!uri.isAbsolute()) {
        return Mono.error(new IllegalArgumentException("URI is not absolute: " + uri));
    } 
    return this.httpClient.request(io.netty.handler.codec.http.HttpMethod.valueOf(method.name())).uri(uri.toString()).send((request, outbound) -> requestCallback.apply(adaptRequest(method, uri, request, outbound))).responseConnection((res, con) -> Mono.just(adaptResponse(res, con.inbound(), con.outbound().alloc()))).next();
}
 ReactorClientHttpRequest
 extends AbstractClientHttpRequest implements ZeroCopyHttpOutputMessage
org.springframework.http.client.reactive.ReactorClientHttpRequest
public ReactorClientHttpRequest ReactorClientHttpRequest(HttpMethod method, URI uri, HttpClientRequest request, NettyOutbound outbound)
{
    this.httpMethod = method;
    this.uri = uri;
    this.request = request;
    this.outbound = outbound;
    this.bufferFactory = new NettyDataBufferFactory(outbound.alloc());
}
org.springframework.http.client.reactive.ReactorClientHttpRequest
@Override protected void applyHeaders()
{
    getHeaders().forEach((key, value) -> this.request.requestHeaders().set(key, value));
}
org.springframework.http.client.reactive.ReactorClientHttpRequest
@Override public DataBufferFactory bufferFactory()
{
    return this.bufferFactory;
}
org.springframework.http.client.reactive.ReactorClientHttpRequest
@Override public HttpMethod getMethod()
{
    return this.httpMethod;
}
org.springframework.http.client.reactive.ReactorClientHttpRequest
@Override public URI getURI()
{
    return this.uri;
}
org.springframework.http.client.reactive.ReactorClientHttpRequest
@Override public Mono<Void> setComplete()
{
    return doCommit(this.outbound::then);
}
org.springframework.http.client.reactive.ReactorClientHttpRequest
@Override public Mono<Void> writeAndFlushWith(Publisher<?> body)
{
    Publisher<Publisher<ByteBuf>> byteBufs = Flux.from(body).map(ReactorClientHttpRequest::toByteBufs);
    return doCommit(() -> this.outbound.sendGroups(byteBufs).then());
}
org.springframework.http.client.reactive.ReactorClientHttpRequest
@Override public Mono<Void> writeWith(Path file, long position, long count)
{
    return doCommit(() -> this.outbound.sendFile(file, position, count).then());
}
 ReactorClientHttpResponse
 implements ClientHttpResponse
org.springframework.http.client.reactive.ReactorClientHttpResponse
public ReactorClientHttpResponse ReactorClientHttpResponse(HttpClientResponse response, NettyInbound inbound, ByteBufAllocator alloc)
{
    this.response = response;
    this.inbound = inbound;
    this.bufferFactory = new NettyDataBufferFactory(alloc);
}
org.springframework.http.client.reactive.ReactorClientHttpResponse
@Override public Flux<DataBuffer> getBody()
{
    return this.inbound.receive().doOnSubscribe(s -> {
        if (this.rejectSubscribers.get()) {
            throw new IllegalStateException("The client response body can only be consumed once.");
        } 
    }).doOnCancel(() -> this.rejectSubscribers.set(true)).map(byteBuf -> {
        byteBuf.retain();
        return this.bufferFactory.wrap(byteBuf);
    });
}
org.springframework.http.client.reactive.ReactorClientHttpResponse
@Override public HttpHeaders getHeaders()
{
    HttpHeaders headers = new HttpHeaders();
    this.response.responseHeaders().entries().forEach(e -> headers.add(e.getKey(), e.getValue()));
    return headers;
}
org.springframework.http.client.reactive.ReactorClientHttpResponse
@Override public int getRawStatusCode()
{
    return this.response.status().code();
}
org.springframework.http.client.reactive.ReactorClientHttpResponse
@Override public HttpStatus getStatusCode()
{
    return HttpStatus.valueOf(getRawStatusCode());
}
 ReactorResourceFactory
 implements InitializingBean, DisposableBean
org.springframework.http.client.reactive.ReactorResourceFactory
public void addGlobalResourcesConsumer(Consumer<HttpResources> consumer)
{
    this.useGlobalResources = true;
    this.globalResourcesConsumer = this.globalResourcesConsumer != null ? this.globalResourcesConsumer.andThen(consumer) : consumer;
}
org.springframework.http.client.reactive.ReactorResourceFactory
public ConnectionProvider getConnectionProvider()
{
    Assert.state(this.connectionProvider != null, "ConnectionProvider not initialized yet");
    return this.connectionProvider;
}
org.springframework.http.client.reactive.ReactorResourceFactory
public LoopResources getLoopResources()
{
    Assert.state(this.loopResources != null, "LoopResources not initialized yet");
    return this.loopResources;
}
org.springframework.http.client.reactive.ReactorResourceFactory
public boolean isUseGlobalResources()
{
    return this.useGlobalResources;
}
org.springframework.http.client.reactive.ReactorResourceFactory
public void setConnectionProvider(ConnectionProvider connectionProvider)
{
    this.connectionProvider = connectionProvider;
}
org.springframework.http.client.reactive.ReactorResourceFactory
public void setConnectionProviderSupplier(Supplier<ConnectionProvider> supplier)
{
    this.connectionProviderSupplier = supplier;
}
org.springframework.http.client.reactive.ReactorResourceFactory
public void setLoopResources(LoopResources loopResources)
{
    this.loopResources = loopResources;
}
org.springframework.http.client.reactive.ReactorResourceFactory
public void setLoopResourcesSupplier(Supplier<LoopResources> supplier)
{
    this.loopResourcesSupplier = supplier;
}
org.springframework.http.client.reactive.ReactorResourceFactory
public void setUseGlobalResources(boolean useGlobalResources)
{
    this.useGlobalResources = useGlobalResources;
}
 AsyncHttpAccessor
org.springframework.http.client.support.AsyncHttpAccessor
protected org.springframework.http.client.AsyncClientHttpRequest createAsyncRequest(URI url, HttpMethod method)
{
    org.springframework.http.client.AsyncClientHttpRequest request = getAsyncRequestFactory().createAsyncRequest(url, method);
    if (logger.isDebugEnabled()) {
        logger.debug("Created asynchronous " + method.name() + " request for \"" + url + "\"");
    } 
    return request;
}
org.springframework.http.client.support.AsyncHttpAccessor
public org.springframework.http.client.AsyncClientHttpRequestFactory getAsyncRequestFactory()
{
    Assert.state(this.asyncRequestFactory != null, "No AsyncClientHttpRequestFactory set");
    return this.asyncRequestFactory;
}
org.springframework.http.client.support.AsyncHttpAccessor
protected final Log logger
org.springframework.http.client.support.AsyncHttpAccessor
public void setAsyncRequestFactory(org.springframework.http.client.AsyncClientHttpRequestFactory asyncRequestFactory)
{
    Assert.notNull(asyncRequestFactory, "AsyncClientHttpRequestFactory must not be null");
    this.asyncRequestFactory = asyncRequestFactory;
}
 BasicAuthenticationInterceptor
 implements ClientHttpRequestInterceptor
org.springframework.http.client.support.BasicAuthenticationInterceptor
public BasicAuthenticationInterceptor BasicAuthenticationInterceptor(String username, String password)
{
    this(username, password, null);
}
org.springframework.http.client.support.BasicAuthenticationInterceptor
public BasicAuthenticationInterceptor BasicAuthenticationInterceptor(String username, String password, @Nullable Charset charset)
{
    this.encodedCredentials = HttpHeaders.encodeBasicAuth(username, password, charset);
}
org.springframework.http.client.support.BasicAuthenticationInterceptor
@Override public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution)
{
    HttpHeaders headers = request.getHeaders();
    if (!headers.containsKey(HttpHeaders.AUTHORIZATION)) {
        headers.setBasicAuth(this.encodedCredentials);
    } 
    return execution.execute(request, body);
}
 BasicAuthorizationInterceptor
 implements ClientHttpRequestInterceptor
org.springframework.http.client.support.BasicAuthorizationInterceptor
public BasicAuthorizationInterceptor BasicAuthorizationInterceptor(@Nullable String username, @Nullable String password)
{
    Assert.doesNotContain(username, ":", "Username must not contain a colon");
    this.username = (username != null ? username : "");
    this.password = (password != null ? password : "");
}
org.springframework.http.client.support.BasicAuthorizationInterceptor
@Override public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution)
{
    String token = Base64Utils.encodeToString((this.username + ":" + this.password).getBytes(StandardCharsets.UTF_8));
    request.getHeaders().add("Authorization", "Basic " + token);
    return execution.execute(request, body);
}
 HttpAccessor
org.springframework.http.client.support.HttpAccessor
protected ClientHttpRequest createRequest(URI url, HttpMethod method)
{
    ClientHttpRequest request = getRequestFactory().createRequest(url, method);
    initialize(request);
    if (logger.isDebugEnabled()) {
        logger.debug("HTTP " + method.name() + " " + url);
    } 
    return request;
}
org.springframework.http.client.support.HttpAccessor
public List<ClientHttpRequestInitializer> getClientHttpRequestInitializers()
{
    return this.clientHttpRequestInitializers;
}
org.springframework.http.client.support.HttpAccessor
public ClientHttpRequestFactory getRequestFactory()
{
    return this.requestFactory;
}
org.springframework.http.client.support.HttpAccessor
protected final Log logger
org.springframework.http.client.support.HttpAccessor
public void setRequestFactory(ClientHttpRequestFactory requestFactory)
{
    Assert.notNull(requestFactory, "ClientHttpRequestFactory must not be null");
    this.requestFactory = requestFactory;
}
 HttpRequestWrapper
 implements HttpRequest
org.springframework.http.client.support.HttpRequestWrapper
public HttpRequestWrapper HttpRequestWrapper(HttpRequest request)
{
    Assert.notNull(request, "HttpRequest must not be null");
    this.request = request;
}
org.springframework.http.client.support.HttpRequestWrapper
@Override public HttpHeaders getHeaders()
{
    return this.request.getHeaders();
}
org.springframework.http.client.support.HttpRequestWrapper
@Override @Nullable public HttpMethod getMethod()
{
    return this.request.getMethod();
}
org.springframework.http.client.support.HttpRequestWrapper
@Override public String getMethodValue()
{
    return this.request.getMethodValue();
}
org.springframework.http.client.support.HttpRequestWrapper
public HttpRequest getRequest()
{
    return this.request;
}
org.springframework.http.client.support.HttpRequestWrapper
@Override public URI getURI()
{
    return this.request.getURI();
}
 InterceptingAsyncHttpAccessor
 extends AsyncHttpAccessor
org.springframework.http.client.support.InterceptingAsyncHttpAccessor
public List<org.springframework.http.client.AsyncClientHttpRequestInterceptor> getInterceptors()
{
    return this.interceptors;
}
org.springframework.http.client.support.InterceptingAsyncHttpAccessor
public void setInterceptors(List<org.springframework.http.client.AsyncClientHttpRequestInterceptor> interceptors)
{
    this.interceptors = interceptors;
}
 InterceptingHttpAccessor
 extends HttpAccessor
org.springframework.http.client.support.InterceptingHttpAccessor
public List<ClientHttpRequestInterceptor> getInterceptors()
{
    return this.interceptors;
}
org.springframework.http.client.support.InterceptingHttpAccessor
@Nullable volatile ClientHttpRequestFactory interceptingRequestFactory
org.springframework.http.client.support.InterceptingHttpAccessor
public void setInterceptors(List<ClientHttpRequestInterceptor> interceptors)
{
    if (this.interceptors != interceptors) {
        this.interceptors.clear();
        this.interceptors.addAll(interceptors);
        AnnotationAwareOrderComparator.sort(this.interceptors);
    } 
}
org.springframework.http.client.support.InterceptingHttpAccessor
@Override public void setRequestFactory(ClientHttpRequestFactory requestFactory)
{
    super.setRequestFactory(requestFactory);
    this.interceptingRequestFactory = null;
}
 ProxyFactoryBean
 implements FactoryBean<Proxy>, InitializingBean
org.springframework.http.client.support.ProxyFactoryBean
@Override public void afterPropertiesSet()
{
    Assert.notNull(this.type, "Property 'type' is required");
    Assert.notNull(this.hostname, "Property 'hostname' is required");
    if (this.port < 0 || this.port > 65535) {
        throw new IllegalArgumentException("Property 'port' value out of range: " + this.port);
    } 
    SocketAddress socketAddress = new InetSocketAddress(this.hostname, this.port);
    this.proxy = new Proxy(this.type, socketAddress);
}
org.springframework.http.client.support.ProxyFactoryBean
@Override @Nullable public Proxy getObject()
{
    return this.proxy;
}
org.springframework.http.client.support.ProxyFactoryBean
@Override public Class<?> getObjectType()
{
    return Proxy.class;
}
org.springframework.http.client.support.ProxyFactoryBean
@Override public boolean isSingleton()
{
    return true;
}
org.springframework.http.client.support.ProxyFactoryBean
public void setHostname(String hostname)
{
    this.hostname = hostname;
}
org.springframework.http.client.support.ProxyFactoryBean
public void setPort(int port)
{
    this.port = port;
}
org.springframework.http.client.support.ProxyFactoryBean
public void setType(Proxy.Type type)
{
    this.type = type;
}
 ClientCodecConfigurer
inherit classes
  • CodecConfigurer
 CodecConfigurer
 CodecConfigurerFactory
org.springframework.http.codec.CodecConfigurerFactory
<T>@SuppressWarnings("unchecked") public static T create(Class<T> ifc)
{
    Class<?> impl = defaultCodecConfigurers.get(ifc);
    if (impl == null) {
        throw new IllegalStateException("No default codec configurer found for " + ifc);
    } 
    return (T)BeanUtils.instantiateClass(impl);
}
 DecoderHttpMessageReader<T>
 implements HttpMessageReader<T>
org.springframework.http.codec.DecoderHttpMessageReader
public DecoderHttpMessageReader DecoderHttpMessageReader(Decoder<T> decoder)
{
    Assert.notNull(decoder, "Decoder is required");
    initLogger(decoder);
    this.decoder = decoder;
    this.mediaTypes = MediaType.asMediaTypes(decoder.getDecodableMimeTypes());
}
org.springframework.http.codec.DecoderHttpMessageReader
@Override public boolean canRead(ResolvableType elementType, @Nullable MediaType mediaType)
{
    return this.decoder.canDecode(elementType, mediaType);
}
org.springframework.http.codec.DecoderHttpMessageReader
@Nullable protected MediaType getContentType(HttpMessage inputMessage)
{
    MediaType contentType = inputMessage.getHeaders().getContentType();
    return (contentType != null ? contentType : MediaType.APPLICATION_OCTET_STREAM);
}
org.springframework.http.codec.DecoderHttpMessageReader
public Decoder<T> getDecoder()
{
    return this.decoder;
}
org.springframework.http.codec.DecoderHttpMessageReader
protected Map<String, Object> getReadHints(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response)
{
    if (this.decoder instanceof HttpMessageDecoder) {
        HttpMessageDecoder<?> decoder = (HttpMessageDecoder<?>)this.decoder;
        return decoder.getDecodeHints(actualType, elementType, request, response);
    } 
    return Hints.none();
}
org.springframework.http.codec.DecoderHttpMessageReader
@Override public List<MediaType> getReadableMediaTypes()
{
    return this.mediaTypes;
}
org.springframework.http.codec.DecoderHttpMessageReader
@Override public Flux<T> read(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String, Object> hints)
{
    MediaType contentType = getContentType(message);
    return this.decoder.decode(message.getBody(), elementType, contentType, hints);
}
org.springframework.http.codec.DecoderHttpMessageReader
@Override public Flux<T> read(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response, Map<String, Object> hints)
{
    Map<String, Object> allHints = Hints.merge(hints, getReadHints(actualType, elementType, request, response));
    return read(elementType, request, allHints);
}
org.springframework.http.codec.DecoderHttpMessageReader
@Override public Mono<T> readMono(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String, Object> hints)
{
    MediaType contentType = getContentType(message);
    return this.decoder.decodeToMono(message.getBody(), elementType, contentType, hints);
}
org.springframework.http.codec.DecoderHttpMessageReader
@Override public Mono<T> readMono(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response, Map<String, Object> hints)
{
    Map<String, Object> allHints = Hints.merge(hints, getReadHints(actualType, elementType, request, response));
    return readMono(elementType, request, allHints);
}
 EncoderHttpMessageWriter<T>
 implements HttpMessageWriter<T>
org.springframework.http.codec.EncoderHttpMessageWriter
@Override public boolean canWrite(ResolvableType elementType, @Nullable MediaType mediaType)
{
    return this.encoder.canEncode(elementType, mediaType);
}
org.springframework.http.codec.EncoderHttpMessageWriter
public Encoder<T> getEncoder()
{
    return this.encoder;
}
org.springframework.http.codec.EncoderHttpMessageWriter
@Override public List<MediaType> getWritableMediaTypes()
{
    return this.mediaTypes;
}
org.springframework.http.codec.EncoderHttpMessageWriter
protected Map<String, Object> getWriteHints(ResolvableType streamType, ResolvableType elementType, @Nullable MediaType mediaType, ServerHttpRequest request, ServerHttpResponse response)
{
    if (this.encoder instanceof HttpMessageEncoder) {
        HttpMessageEncoder<?> encoder = (HttpMessageEncoder<?>)this.encoder;
        return encoder.getEncodeHints(streamType, elementType, mediaType, request, response);
    } 
    return Hints.none();
}
org.springframework.http.codec.EncoderHttpMessageWriter
@Override public Mono<Void> write(Publisher<?> inputStream, ResolvableType actualType, ResolvableType elementType, @Nullable MediaType mediaType, ServerHttpRequest request, ServerHttpResponse response, Map<String, Object> hints)
{
    Map<String, Object> allHints = Hints.merge(hints, getWriteHints(actualType, elementType, mediaType, request, response));
    return write(inputStream, elementType, mediaType, response, allHints);
}
 FormHttpMessageReader
 extends LoggingCodecSupport implements HttpMessageReader<MultiValueMap<String, String>>
org.springframework.http.codec.FormHttpMessageReader
public static final Charset DEFAULT_CHARSET
org.springframework.http.codec.FormHttpMessageReader
public Charset getDefaultCharset()
{
    return this.defaultCharset;
}
org.springframework.http.codec.FormHttpMessageReader
@Override public List<MediaType> getReadableMediaTypes()
{
    return Collections.singletonList(MediaType.APPLICATION_FORM_URLENCODED);
}
org.springframework.http.codec.FormHttpMessageReader
@Override public Flux<MultiValueMap<String, String>> read(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String, Object> hints)
{
    return Flux.from(readMono(elementType, message, hints));
}
org.springframework.http.codec.FormHttpMessageReader
public void setDefaultCharset(Charset charset)
{
    Assert.notNull(charset, "Charset must not be null");
    this.defaultCharset = charset;
}
 FormHttpMessageWriter
 extends LoggingCodecSupport implements HttpMessageWriter<MultiValueMap<String, String>>
org.springframework.http.codec.FormHttpMessageWriter
public static final Charset DEFAULT_CHARSET
org.springframework.http.codec.FormHttpMessageWriter
@Override public boolean canWrite(ResolvableType elementType, @Nullable MediaType mediaType)
{
    if (!MultiValueMap.class.isAssignableFrom(elementType.toClass())) {
        return false;
    } 
    if (MediaType.APPLICATION_FORM_URLENCODED.isCompatibleWith(mediaType)) {
        return true;
    } 
    if (mediaType == null) {
        return MULTIVALUE_TYPE.isAssignableFrom(elementType);
    } 
    return false;
}
org.springframework.http.codec.FormHttpMessageWriter
public Charset getDefaultCharset()
{
    return this.defaultCharset;
}
org.springframework.http.codec.FormHttpMessageWriter
protected MediaType getMediaType(@Nullable MediaType mediaType)
{
    if (mediaType == null) {
        return DEFAULT_FORM_DATA_MEDIA_TYPE;
    } else if (mediaType.getCharset() == null) {
        return new MediaType(mediaType, getDefaultCharset());
    } else {
        return mediaType;
    }
}
org.springframework.http.codec.FormHttpMessageWriter
@Override public List<MediaType> getWritableMediaTypes()
{
    return MEDIA_TYPES;
}
org.springframework.http.codec.FormHttpMessageWriter
protected String serializeForm(MultiValueMap<String, String> formData, Charset charset)
{
    StringBuilder builder = new StringBuilder();
    formData.forEach((name, values) -> values.forEach(value -> {
        try {
            if (builder.length() != 0) {
                builder.append('&');
            } 
            builder.append(URLEncoder.encode(name, charset.name()));
            if (value != null) {
                builder.append('=');
                builder.append(URLEncoder.encode(value, charset.name()));
            } 
        } catch (UnsupportedEncodingException ex) {
            throw new IllegalStateException(ex);
        }
    }));
    return builder.toString();
}
org.springframework.http.codec.FormHttpMessageWriter
public void setDefaultCharset(Charset charset)
{
    Assert.notNull(charset, "Charset must not be null");
    this.defaultCharset = charset;
}
 HttpMessageDecoder
inherit classes
  • Decoder<T>
 HttpMessageEncoder
inherit classes
  • Encoder<T>
 HttpMessageReader
 HttpMessageWriter
 LoggingCodecSupport
org.springframework.http.codec.LoggingCodecSupport
public boolean isEnableLoggingRequestDetails()
{
    return this.enableLoggingRequestDetails;
}
org.springframework.http.codec.LoggingCodecSupport
protected final Log logger
org.springframework.http.codec.LoggingCodecSupport
public void setEnableLoggingRequestDetails(boolean enable)
{
    this.enableLoggingRequestDetails = enable;
}
 ResourceHttpMessageReader
 extends DecoderHttpMessageReader<Resource>
org.springframework.http.codec.ResourceHttpMessageReader
public ResourceHttpMessageReader ResourceHttpMessageReader()
{
    super(new ResourceDecoder());
}
org.springframework.http.codec.ResourceHttpMessageReader
public ResourceHttpMessageReader ResourceHttpMessageReader(ResourceDecoder resourceDecoder)
{
    super(resourceDecoder);
}
org.springframework.http.codec.ResourceHttpMessageReader
@Override protected Map<String, Object> getReadHints(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response)
{
    String name = request.getHeaders().getContentDisposition().getFilename();
    return StringUtils.hasText(name) ? Hints.from(ResourceDecoder.FILENAME_HINT, name) : Hints.none();
}
 ResourceHttpMessageWriter
 implements HttpMessageWriter<Resource>
org.springframework.http.codec.ResourceHttpMessageWriter
public ResourceHttpMessageWriter ResourceHttpMessageWriter()
{
    this(ResourceEncoder.DEFAULT_BUFFER_SIZE);
}
org.springframework.http.codec.ResourceHttpMessageWriter
public ResourceHttpMessageWriter ResourceHttpMessageWriter(int bufferSize)
{
    this.encoder = new ResourceEncoder(bufferSize);
    this.regionEncoder = new ResourceRegionEncoder(bufferSize);
    this.mediaTypes = MediaType.asMediaTypes(this.encoder.getEncodableMimeTypes());
}
org.springframework.http.codec.ResourceHttpMessageWriter
@Override public boolean canWrite(ResolvableType elementType, @Nullable MediaType mediaType)
{
    return this.encoder.canEncode(elementType, mediaType);
}
org.springframework.http.codec.ResourceHttpMessageWriter
@Override public List<MediaType> getWritableMediaTypes()
{
    return this.mediaTypes;
}
org.springframework.http.codec.ResourceHttpMessageWriter
@Override public Mono<Void> write(Publisher<?> inputStream, ResolvableType elementType, @Nullable MediaType mediaType, ReactiveHttpOutputMessage message, Map<String, Object> hints)
{
    return Mono.from(inputStream).flatMap(resource -> writeResource(resource, elementType, mediaType, message, hints));
}
org.springframework.http.codec.ResourceHttpMessageWriter
@Override public Mono<Void> write(Publisher<?> inputStream, @Nullable ResolvableType actualType, ResolvableType elementType, @Nullable MediaType mediaType, ServerHttpRequest request, ServerHttpResponse response, Map<String, Object> hints)
{
    HttpHeaders headers = response.getHeaders();
    headers.set(HttpHeaders.ACCEPT_RANGES, "bytes");
    List < HttpRange > ranges;
    try {
        ranges = request.getHeaders().getRange();
    } catch (IllegalArgumentException ex) {
        response.setStatusCode(HttpStatus.REQUESTED_RANGE_NOT_SATISFIABLE);
        return response.setComplete();
    }
    return Mono.from(inputStream).flatMap(resource -> {
        if (ranges.isEmpty()) {
            return writeResource(resource, elementType, mediaType, response, hints);
        } 
        response.setStatusCode(HttpStatus.PARTIAL_CONTENT);
        List<ResourceRegion> regions = HttpRange.toResourceRegions(ranges, resource);
        MediaType resourceMediaType = getResourceMediaType(mediaType, resource, hints);
        if (regions.size() == 1) {
            ResourceRegion region = regions.get(0);
            headers.setContentType(resourceMediaType);
            long contentLength = lengthOf(resource);
            if (contentLength != -1) {
                long start = region.getPosition();
                long end = start + region.getCount() - 1;
                end = Math.min(end, contentLength - 1);
                headers.add("Content-Range", "bytes " + start + '-' + end + '/' + contentLength);
                headers.setContentLength(end - start + 1);
            } 
            return writeSingleRegion(region, response, hints);
        } else {
            String boundary = MimeTypeUtils.generateMultipartBoundaryString();
            MediaType multipartType = MediaType.parseMediaType("multipart/byteranges;boundary=" + boundary);
            headers.setContentType(multipartType);
            Map<String, Object> allHints = Hints.merge(hints, ResourceRegionEncoder.BOUNDARY_STRING_HINT, boundary);
            return encodeAndWriteRegions(Flux.fromIterable(regions), resourceMediaType, response, allHints);
        }
    });
}
 ServerCodecConfigurer
inherit classes
  • CodecConfigurer
 ServerSentEvent<T>
 Builder
org.springframework.http.codec.ServerSentEvent
<T>public static Builder<T> builder()
{
    return new BuilderImpl<>();
}
org.springframework.http.codec.ServerSentEvent
<T>public static Builder<T> builder(T data)
{
    return new BuilderImpl<>(data);
}
org.springframework.http.codec.ServerSentEvent
@Nullable public String comment()
{
    return this.comment;
}
org.springframework.http.codec.ServerSentEvent
@Nullable public T data()
{
    return this.data;
}
org.springframework.http.codec.ServerSentEvent
@Nullable public String event()
{
    return this.event;
}
org.springframework.http.codec.ServerSentEvent
@Nullable public String id()
{
    return this.id;
}
org.springframework.http.codec.ServerSentEvent
@Nullable public Duration retry()
{
    return this.retry;
}
 ServerSentEventHttpMessageReader
 implements HttpMessageReader<Object>
org.springframework.http.codec.ServerSentEventHttpMessageReader
public ServerSentEventHttpMessageReader ServerSentEventHttpMessageReader()
{
    this(null);
}
org.springframework.http.codec.ServerSentEventHttpMessageReader
public ServerSentEventHttpMessageReader ServerSentEventHttpMessageReader(@Nullable Decoder<?> decoder)
{
    this.decoder = decoder;
}
org.springframework.http.codec.ServerSentEventHttpMessageReader
@Override public boolean canRead(ResolvableType elementType, @Nullable MediaType mediaType)
{
    return (MediaType.TEXT_EVENT_STREAM.includes(mediaType) || isServerSentEvent(elementType));
}
org.springframework.http.codec.ServerSentEventHttpMessageReader
@Nullable public Decoder<?> getDecoder()
{
    return this.decoder;
}
org.springframework.http.codec.ServerSentEventHttpMessageReader
@Override public List<MediaType> getReadableMediaTypes()
{
    return Collections.singletonList(MediaType.TEXT_EVENT_STREAM);
}
org.springframework.http.codec.ServerSentEventHttpMessageReader
@Override public Mono<Object> readMono(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String, Object> hints)
{
    if (elementType.resolve() == String.class) {
        Flux<DataBuffer> body = message.getBody();
        return stringDecoder.decodeToMono(body, elementType, null, null).cast(Object.class);
    } 
    return Mono.error(new UnsupportedOperationException("ServerSentEventHttpMessageReader only supports reading stream of events as a Flux"));
}
 ServerSentEventHttpMessageWriter
 implements HttpMessageWriter<Object>
org.springframework.http.codec.ServerSentEventHttpMessageWriter
public ServerSentEventHttpMessageWriter ServerSentEventHttpMessageWriter()
{
    this(null);
}
org.springframework.http.codec.ServerSentEventHttpMessageWriter
public ServerSentEventHttpMessageWriter ServerSentEventHttpMessageWriter(@Nullable Encoder<?> encoder)
{
    this.encoder = encoder;
}
org.springframework.http.codec.ServerSentEventHttpMessageWriter
@Override public boolean canWrite(ResolvableType elementType, @Nullable MediaType mediaType)
{
    return (mediaType == null || MediaType.TEXT_EVENT_STREAM.includes(mediaType) || ServerSentEvent.class.isAssignableFrom(elementType.toClass()));
}
org.springframework.http.codec.ServerSentEventHttpMessageWriter
@Nullable public Encoder<?> getEncoder()
{
    return this.encoder;
}
org.springframework.http.codec.ServerSentEventHttpMessageWriter
@Override public List<MediaType> getWritableMediaTypes()
{
    return WRITABLE_MEDIA_TYPES;
}
org.springframework.http.codec.ServerSentEventHttpMessageWriter
@Override public Mono<Void> write(Publisher<?> input, ResolvableType elementType, @Nullable MediaType mediaType, ReactiveHttpOutputMessage message, Map<String, Object> hints)
{
    mediaType = (mediaType != null && mediaType.getCharset() != null ? mediaType : DEFAULT_MEDIA_TYPE);
    DataBufferFactory bufferFactory = message.bufferFactory();
    message.getHeaders().setContentType(mediaType);
    return message.writeAndFlushWith(encode(input, elementType, mediaType, bufferFactory, hints));
}
org.springframework.http.codec.ServerSentEventHttpMessageWriter
@Override public Mono<Void> write(Publisher<?> input, ResolvableType actualType, ResolvableType elementType, @Nullable MediaType mediaType, ServerHttpRequest request, ServerHttpResponse response, Map<String, Object> hints)
{
    Map<String, Object> allHints = Hints.merge(hints, getEncodeHints(actualType, elementType, mediaType, request, response));
    return write(input, elementType, mediaType, response, allHints);
}
 Jackson2CborDecoder
 extends AbstractJackson2Decoder
org.springframework.http.codec.cbor.Jackson2CborDecoder
public Jackson2CborDecoder Jackson2CborDecoder()
{
    this(Jackson2ObjectMapperBuilder.cbor().build(), MediaType.APPLICATION_CBOR);
}
org.springframework.http.codec.cbor.Jackson2CborDecoder
public Jackson2CborDecoder Jackson2CborDecoder(ObjectMapper mapper, MimeType... mimeTypes)
{
    super(mapper, mimeTypes);
    Assert.isAssignable(CBORFactory.class, mapper.getFactory().getClass());
}
org.springframework.http.codec.cbor.Jackson2CborDecoder
@Override public Flux<Object> decode(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String, Object> hints)
{
    throw new UnsupportedOperationException("Does not support stream decoding yet");
}
 Jackson2CborEncoder
 extends AbstractJackson2Encoder
org.springframework.http.codec.cbor.Jackson2CborEncoder
public Jackson2CborEncoder Jackson2CborEncoder()
{
    this(Jackson2ObjectMapperBuilder.cbor().build(), MediaType.APPLICATION_CBOR);
}
org.springframework.http.codec.cbor.Jackson2CborEncoder
public Jackson2CborEncoder Jackson2CborEncoder(ObjectMapper mapper, MimeType... mimeTypes)
{
    super(mapper, mimeTypes);
    Assert.isAssignable(CBORFactory.class, mapper.getFactory().getClass());
}
org.springframework.http.codec.cbor.Jackson2CborEncoder
@Override public Flux<DataBuffer> encode(Publisher<?> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String, Object> hints)
{
    throw new UnsupportedOperationException("Does not support stream encoding yet");
}
 AbstractJackson2Decoder
 extends Jackson2CodecSupport implements HttpMessageDecoder<Object>
org.springframework.http.codec.json.AbstractJackson2Decoder
protected AbstractJackson2Decoder AbstractJackson2Decoder(ObjectMapper mapper, MimeType... mimeTypes)
{
    super(mapper, mimeTypes);
}
org.springframework.http.codec.json.AbstractJackson2Decoder
@Override public Object decode(DataBuffer dataBuffer, ResolvableType targetType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints)
{
    try {
        ObjectReader objectReader = getObjectReader(targetType, hints);
        Object value = objectReader.readValue(dataBuffer.asInputStream());
        logValue(value, hints);
        return value;
    } catch (IOException ex) {
        throw processException(ex);
    } finally {
        DataBufferUtils.release(dataBuffer);
    }
}
org.springframework.http.codec.json.AbstractJackson2Decoder
@Override public Mono<Object> decodeToMono(Publisher<DataBuffer> input, ResolvableType elementType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints)
{
    return DataBufferUtils.join(input).map(dataBuffer -> decode(dataBuffer, elementType, mimeType, hints));
}
org.springframework.http.codec.json.AbstractJackson2Decoder
<A>@Override protected A getAnnotation(MethodParameter parameter, Class<A> annotType)
{
    return parameter.getParameterAnnotation(annotType);
}
org.springframework.http.codec.json.AbstractJackson2Decoder
@Override public List<MimeType> getDecodableMimeTypes()
{
    return getMimeTypes();
}
org.springframework.http.codec.json.AbstractJackson2Decoder
@Override public Map<String, Object> getDecodeHints(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response)
{
    return getHints(actualType);
}
 AbstractJackson2Encoder
 extends Jackson2CodecSupport implements HttpMessageEncoder<Object>
org.springframework.http.codec.json.AbstractJackson2Encoder
protected AbstractJackson2Encoder AbstractJackson2Encoder(ObjectMapper mapper, MimeType... mimeTypes)
{
    super(mapper, mimeTypes);
}
org.springframework.http.codec.json.AbstractJackson2Encoder
@Override public boolean canEncode(ResolvableType elementType, @Nullable MimeType mimeType)
{
    Class<?> clazz = elementType.toClass();
    return supportsMimeType(mimeType) && (Object.class == clazz || (!String.class.isAssignableFrom(elementType.resolve(clazz)) && getObjectMapper().canSerialize(clazz)));
}
org.springframework.http.codec.json.AbstractJackson2Encoder
protected ObjectWriter customizeWriter(ObjectWriter writer, @Nullable MimeType mimeType, ResolvableType elementType, @Nullable Map<String, Object> hints)
{
    return writer;
}
org.springframework.http.codec.json.AbstractJackson2Encoder
@Override public DataBuffer encodeValue(Object value, DataBufferFactory bufferFactory, ResolvableType valueType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints)
{
    return encodeValue(value, bufferFactory, valueType, mimeType, hints, getJsonEncoding(mimeType));
}
org.springframework.http.codec.json.AbstractJackson2Encoder
<A>@Override protected A getAnnotation(MethodParameter parameter, Class<A> annotType)
{
    return parameter.getMethodAnnotation(annotType);
}
org.springframework.http.codec.json.AbstractJackson2Encoder
@Override public List<MimeType> getEncodableMimeTypes()
{
    return getMimeTypes();
}
org.springframework.http.codec.json.AbstractJackson2Encoder
@Override public Map<String, Object> getEncodeHints(@Nullable ResolvableType actualType, ResolvableType elementType, @Nullable MediaType mediaType, ServerHttpRequest request, ServerHttpResponse response)
{
    return (actualType != null ? getHints(actualType) : Hints.none());
}
org.springframework.http.codec.json.AbstractJackson2Encoder
protected JsonEncoding getJsonEncoding(@Nullable MimeType mimeType)
{
    if (mimeType != null && mimeType.getCharset() != null) {
        Charset charset = mimeType.getCharset();
        for (JsonEncoding encoding: JsonEncoding.values()) {
            if (charset.name().equals(encoding.getJavaName())) {
                return encoding;
            } 
        }
    } 
    return JsonEncoding.UTF8;
}
org.springframework.http.codec.json.AbstractJackson2Encoder
@Override public List<MediaType> getStreamingMediaTypes()
{
    return Collections.unmodifiableList(this.streamingMediaTypes);
}
org.springframework.http.codec.json.AbstractJackson2Encoder
public void setStreamingMediaTypes(List<MediaType> mediaTypes)
{
    this.streamingMediaTypes.clear();
    this.streamingMediaTypes.addAll(mediaTypes);
}
 Jackson2CodecSupport
org.springframework.http.codec.json.Jackson2CodecSupport
public static final String JSON_VIEW_HINT
org.springframework.http.codec.json.Jackson2CodecSupport
protected Jackson2CodecSupport Jackson2CodecSupport(ObjectMapper objectMapper, MimeType... mimeTypes)
{
    Assert.notNull(objectMapper, "ObjectMapper must not be null");
    this.objectMapper = objectMapper;
    this.mimeTypes = !ObjectUtils.isEmpty(mimeTypes) ? Collections.unmodifiableList(Arrays.asList(mimeTypes)) : DEFAULT_MIME_TYPES;
}
org.springframework.http.codec.json.Jackson2CodecSupport
<A>@Nullable protected abstract A getAnnotation(MethodParameter parameter, Class<A> annotType)
org.springframework.http.codec.json.Jackson2CodecSupport
protected JavaType getJavaType(Type type, @Nullable Class<?> contextClass)
{
    TypeFactory typeFactory = this.objectMapper.getTypeFactory();
    return typeFactory.constructType(GenericTypeResolver.resolveType(type, contextClass));
}
org.springframework.http.codec.json.Jackson2CodecSupport
protected List<MimeType> getMimeTypes()
{
    return this.mimeTypes;
}
org.springframework.http.codec.json.Jackson2CodecSupport
public ObjectMapper getObjectMapper()
{
    return this.objectMapper;
}
org.springframework.http.codec.json.Jackson2CodecSupport
@Nullable protected MethodParameter getParameter(ResolvableType type)
{
    return (type.getSource() instanceof MethodParameter ? (MethodParameter)type.getSource() : null);
}
org.springframework.http.codec.json.Jackson2CodecSupport
protected final Log logger
org.springframework.http.codec.json.Jackson2CodecSupport
protected boolean supportsMimeType(@Nullable MimeType mimeType)
{
    return (mimeType == null || this.mimeTypes.stream().anyMatch(m -> m.isCompatibleWith(mimeType)));
}
 Jackson2JsonDecoder
 extends AbstractJackson2Decoder
org.springframework.http.codec.json.Jackson2JsonDecoder
public Jackson2JsonDecoder Jackson2JsonDecoder()
{
    super(Jackson2ObjectMapperBuilder.json().build());
}
org.springframework.http.codec.json.Jackson2JsonDecoder
public Jackson2JsonDecoder Jackson2JsonDecoder(ObjectMapper mapper, MimeType... mimeTypes)
{
    super(mapper, mimeTypes);
}
 Jackson2JsonEncoder
 extends AbstractJackson2Encoder
org.springframework.http.codec.json.Jackson2JsonEncoder
public Jackson2JsonEncoder Jackson2JsonEncoder()
{
    this(Jackson2ObjectMapperBuilder.json().build());
}
org.springframework.http.codec.json.Jackson2JsonEncoder
public Jackson2JsonEncoder Jackson2JsonEncoder(ObjectMapper mapper, MimeType... mimeTypes)
{
    super(mapper, mimeTypes);
    setStreamingMediaTypes(Collections.singletonList(MediaType.APPLICATION_STREAM_JSON));
    this.ssePrettyPrinter = initSsePrettyPrinter();
}
org.springframework.http.codec.json.Jackson2JsonEncoder
@Override protected ObjectWriter customizeWriter(ObjectWriter writer, @Nullable MimeType mimeType, ResolvableType elementType, @Nullable Map<String, Object> hints)
{
    return (this.ssePrettyPrinter != null && MediaType.TEXT_EVENT_STREAM.isCompatibleWith(mimeType) && writer.getConfig().isEnabled(SerializationFeature.INDENT_OUTPUT) ? writer.with(this.ssePrettyPrinter) : writer);
}
 Jackson2SmileDecoder
 extends AbstractJackson2Decoder
org.springframework.http.codec.json.Jackson2SmileDecoder
public Jackson2SmileDecoder Jackson2SmileDecoder()
{
    this(Jackson2ObjectMapperBuilder.smile().build(), DEFAULT_SMILE_MIME_TYPES);
}
org.springframework.http.codec.json.Jackson2SmileDecoder
public Jackson2SmileDecoder Jackson2SmileDecoder(ObjectMapper mapper, MimeType... mimeTypes)
{
    super(mapper, mimeTypes);
    Assert.isAssignable(SmileFactory.class, mapper.getFactory().getClass());
}
 Jackson2SmileEncoder
 extends AbstractJackson2Encoder
org.springframework.http.codec.json.Jackson2SmileEncoder
public Jackson2SmileEncoder Jackson2SmileEncoder()
{
    this(Jackson2ObjectMapperBuilder.smile().build(), DEFAULT_SMILE_MIME_TYPES);
}
org.springframework.http.codec.json.Jackson2SmileEncoder
public Jackson2SmileEncoder Jackson2SmileEncoder(ObjectMapper mapper, MimeType... mimeTypes)
{
    super(mapper, mimeTypes);
    Assert.isAssignable(SmileFactory.class, mapper.getFactory().getClass());
    setStreamingMediaTypes(Collections.singletonList(new MediaType("application", "stream+x-jackson-smile")));
}
 Jackson2Tokenizer
org.springframework.http.codec.json.Jackson2Tokenizer
public static Flux<TokenBuffer> tokenize(Flux<DataBuffer> dataBuffers, JsonFactory jsonFactory, ObjectMapper objectMapper, boolean tokenizeArrayElements)
{
    try {
        JsonParser parser = jsonFactory.createNonBlockingByteArrayParser();
        DeserializationContext context = objectMapper.getDeserializationContext();
        if (context instanceof DefaultDeserializationContext) {
            context = ((DefaultDeserializationContext)context).createInstance(objectMapper.getDeserializationConfig(), parser, objectMapper.getInjectableValues());
        } 
        Jackson2Tokenizer tokenizer = new Jackson2Tokenizer(parser, context, tokenizeArrayElements);
        return dataBuffers.concatMapIterable(tokenizer::tokenize).concatWith(tokenizer.endOfInput());
    } catch (IOException ex) {
        return Flux.error(ex);
    }
}
 FilePart
inherit classes
  • Part
 FormFieldPart
inherit classes
  • Part
 MultipartHttpMessageReader
 extends LoggingCodecSupport implements HttpMessageReader<MultiValueMap<String, Part>>
org.springframework.http.codec.multipart.MultipartHttpMessageReader
public MultipartHttpMessageReader MultipartHttpMessageReader(HttpMessageReader<Part> partReader)
{
    Assert.notNull(partReader, "'partReader' is required");
    this.partReader = partReader;
}
org.springframework.http.codec.multipart.MultipartHttpMessageReader
@Override public boolean canRead(ResolvableType elementType, @Nullable MediaType mediaType)
{
    return MULTIPART_VALUE_TYPE.isAssignableFrom(elementType) && (mediaType == null || MediaType.MULTIPART_FORM_DATA.isCompatibleWith(mediaType));
}
org.springframework.http.codec.multipart.MultipartHttpMessageReader
@Override public List<MediaType> getReadableMediaTypes()
{
    return Collections.singletonList(MediaType.MULTIPART_FORM_DATA);
}
org.springframework.http.codec.multipart.MultipartHttpMessageReader
@Override public Flux<MultiValueMap<String, Part>> read(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String, Object> hints)
{
    return Flux.from(readMono(elementType, message, hints));
}
 MultipartHttpMessageWriter
 extends LoggingCodecSupport implements HttpMessageWriter<MultiValueMap<String, ?>>
org.springframework.http.codec.multipart.MultipartHttpMessageWriter
public static final Charset DEFAULT_CHARSET
org.springframework.http.codec.multipart.MultipartHttpMessageWriter
public MultipartHttpMessageWriter MultipartHttpMessageWriter()
{
    this(Arrays.asList(new EncoderHttpMessageWriter<>(CharSequenceEncoder.textPlainOnly()), new ResourceHttpMessageWriter()));
}
org.springframework.http.codec.multipart.MultipartHttpMessageWriter
public MultipartHttpMessageWriter MultipartHttpMessageWriter(List<HttpMessageWriter<?>> partWriters)
{
    this(partWriters, new FormHttpMessageWriter());
}
org.springframework.http.codec.multipart.MultipartHttpMessageWriter
public MultipartHttpMessageWriter MultipartHttpMessageWriter(List<HttpMessageWriter<?>> partWriters, @Nullable HttpMessageWriter<MultiValueMap<String, String>> formWriter)
{
    this.partWriters = partWriters;
    this.formWriter = formWriter;
    this.supportedMediaTypes = initMediaTypes(formWriter);
}
org.springframework.http.codec.multipart.MultipartHttpMessageWriter
@Override public boolean canWrite(ResolvableType elementType, @Nullable MediaType mediaType)
{
    return (MultiValueMap.class.isAssignableFrom(elementType.toClass()) && (mediaType == null || this.supportedMediaTypes.stream().anyMatch(element -> element.isCompatibleWith(mediaType))));
}
org.springframework.http.codec.multipart.MultipartHttpMessageWriter
protected byte[] generateMultipartBoundary()
{
    return MimeTypeUtils.generateMultipartBoundary();
}
org.springframework.http.codec.multipart.MultipartHttpMessageWriter
public Charset getCharset()
{
    return this.charset;
}
org.springframework.http.codec.multipart.MultipartHttpMessageWriter
public List<HttpMessageWriter<?>> getPartWriters()
{
    return Collections.unmodifiableList(this.partWriters);
}
org.springframework.http.codec.multipart.MultipartHttpMessageWriter
@Override public List<MediaType> getWritableMediaTypes()
{
    return this.supportedMediaTypes;
}
org.springframework.http.codec.multipart.MultipartHttpMessageWriter
public void setCharset(Charset charset)
{
    Assert.notNull(charset, "Charset must not be null");
    this.charset = charset;
}
org.springframework.http.codec.multipart.MultipartHttpMessageWriter
@Override public Mono<Void> write(Publisher<?> inputStream, ResolvableType elementType, @Nullable MediaType mediaType, ReactiveHttpOutputMessage outputMessage, Map<String, Object> hints)
{
    return Mono.from(inputStream).flatMap(map -> {
        if (this.formWriter == null || isMultipart(map, mediaType)) {
            return writeMultipart(map, outputMessage, hints);
        } else {
            @SuppressWarnings("unchecked") Mono<MultiValueMap<String, String>> input = Mono.just((MultiValueMap<String, String>)map);
            return this.formWriter.write(input, elementType, mediaType, outputMessage, hints);
        }
    });
}
 Part
 SynchronossPartHttpMessageReader
 extends LoggingCodecSupport implements HttpMessageReader<Part>
org.springframework.http.codec.multipart.SynchronossPartHttpMessageReader
@Override public boolean canRead(ResolvableType elementType, @Nullable MediaType mediaType)
{
    return Part.class.equals(elementType.toClass()) && (mediaType == null || MediaType.MULTIPART_FORM_DATA.isCompatibleWith(mediaType));
}
org.springframework.http.codec.multipart.SynchronossPartHttpMessageReader
@Override public List<MediaType> getReadableMediaTypes()
{
    return Collections.singletonList(MediaType.MULTIPART_FORM_DATA);
}
org.springframework.http.codec.multipart.SynchronossPartHttpMessageReader
@Override public Mono<Part> readMono(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String, Object> hints)
{
    return Mono.error(new UnsupportedOperationException("Cannot read multipart request body into single Part"));
}
 ProtobufCodecSupport
org.springframework.http.codec.protobuf.ProtobufCodecSupport
protected List<MimeType> getMimeTypes()
{
    return MIME_TYPES;
}
org.springframework.http.codec.protobuf.ProtobufCodecSupport
protected boolean supportsMimeType(@Nullable MimeType mimeType)
{
    return (mimeType == null || MIME_TYPES.stream().anyMatch(m -> m.isCompatibleWith(mimeType)));
}
 ProtobufDecoder
 extends ProtobufCodecSupport implements Decoder<Message>
org.springframework.http.codec.protobuf.ProtobufDecoder
protected static final int DEFAULT_MESSAGE_MAX_SIZE
org.springframework.http.codec.protobuf.ProtobufDecoder
public ProtobufDecoder ProtobufDecoder()
{
    this(ExtensionRegistry.newInstance());
}
org.springframework.http.codec.protobuf.ProtobufDecoder
public ProtobufDecoder ProtobufDecoder(ExtensionRegistry extensionRegistry)
{
    Assert.notNull(extensionRegistry, "ExtensionRegistry must not be null");
    this.extensionRegistry = extensionRegistry;
}
org.springframework.http.codec.protobuf.ProtobufDecoder
@Override public boolean canDecode(ResolvableType elementType, @Nullable MimeType mimeType)
{
    return Message.class.isAssignableFrom(elementType.toClass()) && supportsMimeType(mimeType);
}
org.springframework.http.codec.protobuf.ProtobufDecoder
@Override public Flux<Message> decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints)
{
    MessageDecoderFunction decoderFunction = new MessageDecoderFunction(elementType, this.maxMessageSize);
    return Flux.from(inputStream).flatMapIterable(decoderFunction).doOnTerminate(decoderFunction::discard);
}
org.springframework.http.codec.protobuf.ProtobufDecoder
@Override public Mono<Message> decodeToMono(Publisher<DataBuffer> inputStream, ResolvableType elementType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints)
{
    return DataBufferUtils.join(inputStream).map(dataBuffer -> decode(dataBuffer, elementType, mimeType, hints));
}
org.springframework.http.codec.protobuf.ProtobufDecoder
@Override public List<MimeType> getDecodableMimeTypes()
{
    return getMimeTypes();
}
org.springframework.http.codec.protobuf.ProtobufDecoder
public void setMaxMessageSize(int maxMessageSize)
{
    this.maxMessageSize = maxMessageSize;
}
 ProtobufEncoder
 extends ProtobufCodecSupport implements HttpMessageEncoder<Message>
org.springframework.http.codec.protobuf.ProtobufEncoder
@Override public boolean canEncode(ResolvableType elementType, @Nullable MimeType mimeType)
{
    return Message.class.isAssignableFrom(elementType.toClass()) && supportsMimeType(mimeType);
}
org.springframework.http.codec.protobuf.ProtobufEncoder
@Override public Flux<DataBuffer> encode(Publisher<?> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints)
{
    return Flux.from(inputStream).map(message -> encodeValue(message, bufferFactory, !(inputStream instanceof Mono)));
}
org.springframework.http.codec.protobuf.ProtobufEncoder
@Override public DataBuffer encodeValue(Message message, DataBufferFactory bufferFactory, ResolvableType valueType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints)
{
    return encodeValue(message, bufferFactory, false);
}
org.springframework.http.codec.protobuf.ProtobufEncoder
@Override public List<MimeType> getEncodableMimeTypes()
{
    return getMimeTypes();
}
org.springframework.http.codec.protobuf.ProtobufEncoder
@Override public List<MediaType> getStreamingMediaTypes()
{
    return streamingMediaTypes;
}
 ProtobufHttpMessageWriter
 extends EncoderHttpMessageWriter<Message>
org.springframework.http.codec.protobuf.ProtobufHttpMessageWriter
public ProtobufHttpMessageWriter ProtobufHttpMessageWriter()
{
    super(new ProtobufEncoder());
}
org.springframework.http.codec.protobuf.ProtobufHttpMessageWriter
public ProtobufHttpMessageWriter ProtobufHttpMessageWriter(Encoder<Message> encoder)
{
    super(encoder);
}
 BaseCodecConfigurer
 implements CodecConfigurer
org.springframework.http.codec.support.BaseCodecConfigurer
@Override public CustomCodecs customCodecs()
{
    return this.customCodecs;
}
org.springframework.http.codec.support.BaseCodecConfigurer
@Override public DefaultCodecs defaultCodecs()
{
    return this.defaultCodecs;
}
org.springframework.http.codec.support.BaseCodecConfigurer
@Override public List<HttpMessageWriter<?>> getWriters()
{
    return getWritersInternal(false);
}
org.springframework.http.codec.support.BaseCodecConfigurer
@Override public void registerDefaults(boolean shouldRegister)
{
    this.defaultCodecs.registerDefaults(shouldRegister);
}
 BaseDefaultCodecs
 implements CodecConfigurer.DefaultCodecs
org.springframework.http.codec.support.BaseDefaultCodecs
@Override public void enableLoggingRequestDetails(boolean enable)
{
    this.enableLoggingRequestDetails = enable;
}
org.springframework.http.codec.support.BaseDefaultCodecs
protected void extendObjectReaders(List<HttpMessageReader<?>> objectReaders)
{
}
org.springframework.http.codec.support.BaseDefaultCodecs
protected void extendObjectWriters(List<HttpMessageWriter<?>> objectWriters)
{
}
org.springframework.http.codec.support.BaseDefaultCodecs
protected void extendTypedReaders(List<HttpMessageReader<?>> typedReaders)
{
}
org.springframework.http.codec.support.BaseDefaultCodecs
protected void extendTypedWriters(List<HttpMessageWriter<?>> typedWriters)
{
}
org.springframework.http.codec.support.BaseDefaultCodecs
protected Decoder<?> getJackson2JsonDecoder()
{
    return (this.jackson2JsonDecoder != null ? this.jackson2JsonDecoder : new Jackson2JsonDecoder());
}
org.springframework.http.codec.support.BaseDefaultCodecs
protected Encoder<?> getJackson2JsonEncoder()
{
    return (this.jackson2JsonEncoder != null ? this.jackson2JsonEncoder : new Jackson2JsonEncoder());
}
org.springframework.http.codec.support.BaseDefaultCodecs
protected boolean isEnableLoggingRequestDetails()
{
    return this.enableLoggingRequestDetails;
}
org.springframework.http.codec.support.BaseDefaultCodecs
@Override public void jackson2JsonDecoder(Decoder<?> decoder)
{
    this.jackson2JsonDecoder = decoder;
}
org.springframework.http.codec.support.BaseDefaultCodecs
@Override public void jackson2JsonEncoder(Encoder<?> encoder)
{
    this.jackson2JsonEncoder = encoder;
}
org.springframework.http.codec.support.BaseDefaultCodecs
@Override public void jaxb2Decoder(Decoder<?> decoder)
{
    this.jaxb2Decoder = decoder;
}
org.springframework.http.codec.support.BaseDefaultCodecs
@Override public void jaxb2Encoder(Encoder<?> encoder)
{
    this.jaxb2Encoder = encoder;
}
org.springframework.http.codec.support.BaseDefaultCodecs
@Override public void protobufDecoder(Decoder<?> decoder)
{
    this.protobufDecoder = decoder;
}
org.springframework.http.codec.support.BaseDefaultCodecs
@Override public void protobufEncoder(Encoder<?> encoder)
{
    this.protobufEncoder = encoder;
}
 ClientDefaultCodecsImpl
 extends BaseDefaultCodecs implements ClientCodecConfigurer.ClientDefaultCodecs
org.springframework.http.codec.support.ClientDefaultCodecsImpl
@Override protected void extendObjectReaders(List<HttpMessageReader<?>> objectReaders)
{
    objectReaders.add(new ServerSentEventHttpMessageReader(getSseDecoder()));
}
org.springframework.http.codec.support.ClientDefaultCodecsImpl
@Override public ClientCodecConfigurer.MultipartCodecs multipartCodecs()
{
    if (this.multipartCodecs == null) {
        this.multipartCodecs = new DefaultMultipartCodecs();
    } 
    return this.multipartCodecs;
}
org.springframework.http.codec.support.ClientDefaultCodecsImpl
@Override public void serverSentEventDecoder(Decoder<?> decoder)
{
    this.sseDecoder = decoder;
}
 DefaultClientCodecConfigurer
 extends BaseCodecConfigurer implements ClientCodecConfigurer
org.springframework.http.codec.support.DefaultClientCodecConfigurer
public DefaultClientCodecConfigurer DefaultClientCodecConfigurer()
{
    super(new ClientDefaultCodecsImpl());
    ((ClientDefaultCodecsImpl)defaultCodecs()).setPartWritersSupplier(() -> getWritersInternal(true));
}
org.springframework.http.codec.support.DefaultClientCodecConfigurer
@Override public ClientDefaultCodecs defaultCodecs()
{
    return (ClientDefaultCodecs)super.defaultCodecs();
}
 DefaultServerCodecConfigurer
 extends BaseCodecConfigurer implements ServerCodecConfigurer
org.springframework.http.codec.support.DefaultServerCodecConfigurer
public DefaultServerCodecConfigurer DefaultServerCodecConfigurer()
{
    super(new ServerDefaultCodecsImpl());
}
org.springframework.http.codec.support.DefaultServerCodecConfigurer
@Override public ServerDefaultCodecs defaultCodecs()
{
    return (ServerDefaultCodecs)super.defaultCodecs();
}
 ServerDefaultCodecsImpl
 extends BaseDefaultCodecs implements ServerCodecConfigurer.ServerDefaultCodecs
org.springframework.http.codec.support.ServerDefaultCodecsImpl
@Override protected void extendObjectWriters(List<HttpMessageWriter<?>> objectWriters)
{
    objectWriters.add(new ServerSentEventHttpMessageWriter(getSseEncoder()));
}
org.springframework.http.codec.support.ServerDefaultCodecsImpl
@Override public void serverSentEventEncoder(Encoder<?> encoder)
{
    this.sseEncoder = encoder;
}
 Jaxb2XmlDecoder
 extends AbstractDecoder<Object>
org.springframework.http.codec.xml.Jaxb2XmlDecoder
public Jaxb2XmlDecoder Jaxb2XmlDecoder()
{
    super(MimeTypeUtils.APPLICATION_XML, MimeTypeUtils.TEXT_XML);
}
org.springframework.http.codec.xml.Jaxb2XmlDecoder
public Jaxb2XmlDecoder Jaxb2XmlDecoder(MimeType... supportedMimeTypes)
{
    super(supportedMimeTypes);
}
org.springframework.http.codec.xml.Jaxb2XmlDecoder
@Override public boolean canDecode(ResolvableType elementType, @Nullable MimeType mimeType)
{
    Class<?> outputClass = elementType.toClass();
    return (outputClass.isAnnotationPresent(XmlRootElement.class) || outputClass.isAnnotationPresent(XmlType.class)) && super.canDecode(elementType, mimeType);
}
org.springframework.http.codec.xml.Jaxb2XmlDecoder
@Override @SuppressWarnings({"rawtypes","unchecked","cast"}) public Object decode(DataBuffer dataBuffer, ResolvableType targetType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints)
{
    try {
        Iterator eventReader = inputFactory.createXMLEventReader(dataBuffer.asInputStream());
        List<XMLEvent> events = new ArrayList<>();
        eventReader.forEachRemaining(event -> events.add((XMLEvent)event));
        return unmarshal(events, targetType.toClass());
    } catch (XMLStreamException ex) {
        throw Exceptions.propagate(ex);
    } finally {
        DataBufferUtils.release(dataBuffer);
    }
}
org.springframework.http.codec.xml.Jaxb2XmlDecoder
@Override @SuppressWarnings({"rawtypes","unchecked","cast"}) public Mono<Object> decodeToMono(Publisher<DataBuffer> input, ResolvableType elementType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints)
{
    return DataBufferUtils.join(input).map(dataBuffer -> decode(dataBuffer, elementType, mimeType, hints));
}
org.springframework.http.codec.xml.Jaxb2XmlDecoder
public Function<Unmarshaller, Unmarshaller> getUnmarshallerProcessor()
{
    return this.unmarshallerProcessor;
}
org.springframework.http.codec.xml.Jaxb2XmlDecoder
public void setUnmarshallerProcessor(Function<Unmarshaller, Unmarshaller> processor)
{
    this.unmarshallerProcessor = this.unmarshallerProcessor.andThen(processor);
}
 Jaxb2XmlEncoder
 extends AbstractSingleValueEncoder<Object>
org.springframework.http.codec.xml.Jaxb2XmlEncoder
public Jaxb2XmlEncoder Jaxb2XmlEncoder()
{
    super(MimeTypeUtils.APPLICATION_XML, MimeTypeUtils.TEXT_XML);
}
org.springframework.http.codec.xml.Jaxb2XmlEncoder
@Override protected Flux<DataBuffer> encode(Object value, DataBufferFactory bufferFactory, ResolvableType valueType, @Nullable MimeType mimeType, @Nullable Map<String, Object> hints)
{
    return Mono.fromCallable(() -> encodeValue(value, bufferFactory, valueType, mimeType, hints)).flux();
}
org.springframework.http.codec.xml.Jaxb2XmlEncoder
public Function<Marshaller, Marshaller> getMarshallerProcessor()
{
    return this.marshallerProcessor;
}
org.springframework.http.codec.xml.Jaxb2XmlEncoder
public void setMarshallerProcessor(Function<Marshaller, Marshaller> processor)
{
    this.marshallerProcessor = this.marshallerProcessor.andThen(processor);
}
 JaxbContextContainer
org.springframework.http.codec.xml.JaxbContextContainer
public Marshaller createMarshaller(Class<?> clazz)
{
    JAXBContext jaxbContext = getJaxbContext(clazz);
    return jaxbContext.createMarshaller();
}
org.springframework.http.codec.xml.JaxbContextContainer
public Unmarshaller createUnmarshaller(Class<?> clazz)
{
    JAXBContext jaxbContext = getJaxbContext(clazz);
    return jaxbContext.createUnmarshaller();
}
 XmlEventDecoder
 extends AbstractDecoder<XMLEvent>
org.springframework.http.codec.xml.XmlEventDecoder
public XmlEventDecoder XmlEventDecoder()
{
    super(MimeTypeUtils.APPLICATION_XML, MimeTypeUtils.TEXT_XML);
}
 AbstractGenericHttpMessageConverter<T>
 extends AbstractHttpMessageConverter<T> implements GenericHttpMessageConverter<T>
org.springframework.http.converter.AbstractGenericHttpMessageConverter
protected AbstractGenericHttpMessageConverter AbstractGenericHttpMessageConverter()
{
}
org.springframework.http.converter.AbstractGenericHttpMessageConverter
protected AbstractGenericHttpMessageConverter AbstractGenericHttpMessageConverter(MediaType supportedMediaType)
{
    super(supportedMediaType);
}
org.springframework.http.converter.AbstractGenericHttpMessageConverter
protected AbstractGenericHttpMessageConverter AbstractGenericHttpMessageConverter(MediaType... supportedMediaTypes)
{
    super(supportedMediaTypes);
}
org.springframework.http.converter.AbstractGenericHttpMessageConverter
@Override public boolean canRead(Type type, @Nullable Class<?> contextClass, @Nullable MediaType mediaType)
{
    return (type instanceof Class ? canRead((Class<?>)type, mediaType) : canRead(mediaType));
}
org.springframework.http.converter.AbstractGenericHttpMessageConverter
@Override public boolean canWrite(@Nullable Type type, Class<?> clazz, @Nullable MediaType mediaType)
{
    return canWrite(clazz, mediaType);
}
org.springframework.http.converter.AbstractGenericHttpMessageConverter
@Override protected boolean supports(Class<?> clazz)
{
    return true;
}
org.springframework.http.converter.AbstractGenericHttpMessageConverter
@Override protected void writeInternal(T t, HttpOutputMessage outputMessage)
{
    writeInternal(t, null, outputMessage);
}
org.springframework.http.converter.AbstractGenericHttpMessageConverter
protected abstract void writeInternal(T t, @Nullable Type type, HttpOutputMessage outputMessage)
 AbstractHttpMessageConverter<T>
 implements HttpMessageConverter<T>
org.springframework.http.converter.AbstractHttpMessageConverter
protected AbstractHttpMessageConverter AbstractHttpMessageConverter()
{
}
org.springframework.http.converter.AbstractHttpMessageConverter
protected AbstractHttpMessageConverter AbstractHttpMessageConverter(MediaType supportedMediaType)
{
    setSupportedMediaTypes(Collections.singletonList(supportedMediaType));
}
org.springframework.http.converter.AbstractHttpMessageConverter
protected AbstractHttpMessageConverter AbstractHttpMessageConverter(MediaType... supportedMediaTypes)
{
    setSupportedMediaTypes(Arrays.asList(supportedMediaTypes));
}
org.springframework.http.converter.AbstractHttpMessageConverter
protected AbstractHttpMessageConverter AbstractHttpMessageConverter(Charset defaultCharset, MediaType... supportedMediaTypes)
{
    this.defaultCharset = defaultCharset;
    setSupportedMediaTypes(Arrays.asList(supportedMediaTypes));
}
org.springframework.http.converter.AbstractHttpMessageConverter
@Override public boolean canRead(Class<?> clazz, @Nullable MediaType mediaType)
{
    return supports(clazz) && canRead(mediaType);
}
org.springframework.http.converter.AbstractHttpMessageConverter
protected boolean canRead(@Nullable MediaType mediaType)
{
    if (mediaType == null) {
        return true;
    } 
    for (MediaType supportedMediaType: getSupportedMediaTypes()) {
        if (supportedMediaType.includes(mediaType)) {
            return true;
        } 
    }
    return false;
}
org.springframework.http.converter.AbstractHttpMessageConverter
@Override public boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType)
{
    return supports(clazz) && canWrite(mediaType);
}
org.springframework.http.converter.AbstractHttpMessageConverter
protected boolean canWrite(@Nullable MediaType mediaType)
{
    if (mediaType == null || MediaType.ALL.equalsTypeAndSubtype(mediaType)) {
        return true;
    } 
    for (MediaType supportedMediaType: getSupportedMediaTypes()) {
        if (supportedMediaType.isCompatibleWith(mediaType)) {
            return true;
        } 
    }
    return false;
}
org.springframework.http.converter.AbstractHttpMessageConverter
@Nullable protected Long getContentLength(T t, @Nullable MediaType contentType)
{
    return null;
}
org.springframework.http.converter.AbstractHttpMessageConverter
@Nullable public Charset getDefaultCharset()
{
    return this.defaultCharset;
}
org.springframework.http.converter.AbstractHttpMessageConverter
@Nullable protected MediaType getDefaultContentType(T t)
{
    List<MediaType> mediaTypes = getSupportedMediaTypes();
    return (!mediaTypes.isEmpty() ? mediaTypes.get(0) : null);
}
org.springframework.http.converter.AbstractHttpMessageConverter
@Override public List<MediaType> getSupportedMediaTypes()
{
    return Collections.unmodifiableList(this.supportedMediaTypes);
}
org.springframework.http.converter.AbstractHttpMessageConverter
protected final Log logger
org.springframework.http.converter.AbstractHttpMessageConverter
@Override public final T read(Class<?> clazz, HttpInputMessage inputMessage)
{
    return readInternal(clazz, inputMessage);
}
org.springframework.http.converter.AbstractHttpMessageConverter
protected abstract T readInternal(Class<?> clazz, HttpInputMessage inputMessage)
org.springframework.http.converter.AbstractHttpMessageConverter
public void setDefaultCharset(@Nullable Charset defaultCharset)
{
    this.defaultCharset = defaultCharset;
}
org.springframework.http.converter.AbstractHttpMessageConverter
public void setSupportedMediaTypes(List<MediaType> supportedMediaTypes)
{
    Assert.notEmpty(supportedMediaTypes, "MediaType List must not be empty");
    this.supportedMediaTypes = new ArrayList<>(supportedMediaTypes);
}
org.springframework.http.converter.AbstractHttpMessageConverter
protected abstract boolean supports(Class<?> clazz)
org.springframework.http.converter.AbstractHttpMessageConverter
protected abstract void writeInternal(T t, HttpOutputMessage outputMessage)
 BufferedImageHttpMessageConverter
 implements HttpMessageConverter<BufferedImage>
org.springframework.http.converter.BufferedImageHttpMessageConverter
public BufferedImageHttpMessageConverter BufferedImageHttpMessageConverter()
{
    String[] readerMediaTypes = ImageIO.getReaderMIMETypes();
    for (String mediaType: readerMediaTypes) {
        if (StringUtils.hasText(mediaType)) {
            this.readableMediaTypes.add(MediaType.parseMediaType(mediaType));
        } 
    }
    String[] writerMediaTypes = ImageIO.getWriterMIMETypes();
    for (String mediaType: writerMediaTypes) {
        if (StringUtils.hasText(mediaType)) {
            this.defaultContentType = MediaType.parseMediaType(mediaType);
            break;
        } 
    }
}
org.springframework.http.converter.BufferedImageHttpMessageConverter
@Override public boolean canRead(Class<?> clazz, @Nullable MediaType mediaType)
{
    return (BufferedImage.class == clazz && isReadable(mediaType));
}
org.springframework.http.converter.BufferedImageHttpMessageConverter
@Override public boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType)
{
    return (BufferedImage.class == clazz && isWritable(mediaType));
}
org.springframework.http.converter.BufferedImageHttpMessageConverter
@Nullable public MediaType getDefaultContentType()
{
    return this.defaultContentType;
}
org.springframework.http.converter.BufferedImageHttpMessageConverter
@Override public List<MediaType> getSupportedMediaTypes()
{
    return Collections.unmodifiableList(this.readableMediaTypes);
}
org.springframework.http.converter.BufferedImageHttpMessageConverter
protected void process(ImageReadParam irp)
{
}
org.springframework.http.converter.BufferedImageHttpMessageConverter
protected void process(ImageWriteParam iwp)
{
}
org.springframework.http.converter.BufferedImageHttpMessageConverter
public void setCacheDir(File cacheDir)
{
    Assert.notNull(cacheDir, "'cacheDir' must not be null");
    Assert.isTrue(cacheDir.isDirectory(), "'cacheDir' is not a directory");
    this.cacheDir = cacheDir;
}
 ByteArrayHttpMessageConverter
 extends AbstractHttpMessageConverter<byte[]>
org.springframework.http.converter.ByteArrayHttpMessageConverter
public ByteArrayHttpMessageConverter ByteArrayHttpMessageConverter()
{
    super(MediaType.APPLICATION_OCTET_STREAM, MediaType.ALL);
}
org.springframework.http.converter.ByteArrayHttpMessageConverter
@Override protected Long getContentLength(byte[] bytes, @Nullable MediaType contentType)
{
    return (long)bytes.length;
}
org.springframework.http.converter.ByteArrayHttpMessageConverter
@Override public boolean supports(Class<?> clazz)
{
    return byte[].class == clazz;
}
org.springframework.http.converter.ByteArrayHttpMessageConverter
@Override protected void writeInternal(byte[] bytes, HttpOutputMessage outputMessage)
{
    StreamUtils.copy(bytes, outputMessage.getBody());
}
 FormHttpMessageConverter
 implements HttpMessageConverter<MultiValueMap<String, ?>>
org.springframework.http.converter.FormHttpMessageConverter
public static final Charset DEFAULT_CHARSET
org.springframework.http.converter.FormHttpMessageConverter
public void addPartConverter(HttpMessageConverter<?> partConverter)
{
    Assert.notNull(partConverter, "'partConverter' must not be null");
    this.partConverters.add(partConverter);
}
org.springframework.http.converter.FormHttpMessageConverter
@Override public boolean canRead(Class<?> clazz, @Nullable MediaType mediaType)
{
    if (!MultiValueMap.class.isAssignableFrom(clazz)) {
        return false;
    } 
    if (mediaType == null) {
        return true;
    } 
    for (MediaType supportedMediaType: getSupportedMediaTypes()) {
        if (MULTIPART_ALL.includes(supportedMediaType)) {
            continue;
        } 
        if (supportedMediaType.includes(mediaType)) {
            return true;
        } 
    }
    return false;
}
org.springframework.http.converter.FormHttpMessageConverter
@Override public boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType)
{
    if (!MultiValueMap.class.isAssignableFrom(clazz)) {
        return false;
    } 
    if (mediaType == null || MediaType.ALL.equals(mediaType)) {
        return true;
    } 
    for (MediaType supportedMediaType: getSupportedMediaTypes()) {
        if (supportedMediaType.isCompatibleWith(mediaType)) {
            return true;
        } 
    }
    return false;
}
org.springframework.http.converter.FormHttpMessageConverter
protected byte[] generateMultipartBoundary()
{
    return MimeTypeUtils.generateMultipartBoundary();
}
org.springframework.http.converter.FormHttpMessageConverter
protected HttpEntity<?> getHttpEntity(Object part)
{
    return (part instanceof HttpEntity ? (HttpEntity<?>)part : new HttpEntity<>(part));
}
org.springframework.http.converter.FormHttpMessageConverter
@Override public List<MediaType> getSupportedMediaTypes()
{
    return Collections.unmodifiableList(this.supportedMediaTypes);
}
org.springframework.http.converter.FormHttpMessageConverter
protected String serializeForm(MultiValueMap<String, Object> formData, Charset charset)
{
    StringBuilder builder = new StringBuilder();
    formData.forEach((name, values) -> values.forEach(value -> {
        try {
            if (builder.length() != 0) {
                builder.append('&');
            } 
            builder.append(URLEncoder.encode(name, charset.name()));
            if (value != null) {
                builder.append('=');
                builder.append(URLEncoder.encode(String.valueOf(value), charset.name()));
            } 
        } catch (UnsupportedEncodingException ex) {
            throw new IllegalStateException(ex);
        }
    }));
    return builder.toString();
}
org.springframework.http.converter.FormHttpMessageConverter
public void setCharset(@Nullable Charset charset)
{
    if (charset != this.charset) {
        this.charset = (charset != null ? charset : DEFAULT_CHARSET);
        applyDefaultCharset();
    } 
}
org.springframework.http.converter.FormHttpMessageConverter
public void setMultipartCharset(Charset charset)
{
    this.multipartCharset = charset;
}
org.springframework.http.converter.FormHttpMessageConverter
public void setPartConverters(List<HttpMessageConverter<?>> partConverters)
{
    Assert.notEmpty(partConverters, "'partConverters' must not be empty");
    this.partConverters = partConverters;
}
org.springframework.http.converter.FormHttpMessageConverter
public void setSupportedMediaTypes(List<MediaType> supportedMediaTypes)
{
    Assert.notNull(supportedMediaTypes, "'supportedMediaTypes' must not be null");
    this.supportedMediaTypes = new ArrayList<>(supportedMediaTypes);
}
org.springframework.http.converter.FormHttpMessageConverter
@Override @SuppressWarnings("unchecked") public void write(MultiValueMap<String, ?> map, @Nullable MediaType contentType, HttpOutputMessage outputMessage)
{
    if (isMultipart(map, contentType)) {
        writeMultipart((MultiValueMap<String, Object>)map, contentType, outputMessage);
    } else {
        writeForm((MultiValueMap<String, Object>)map, contentType, outputMessage);
    }
}
 GenericHttpMessageConverter
inherit classes
  • HttpMessageConverter<T>
 HttpMessageConversionException
 extends NestedRuntimeException
org.springframework.http.converter.HttpMessageConversionException
public HttpMessageConversionException HttpMessageConversionException(String msg)
{
    super(msg);
}
org.springframework.http.converter.HttpMessageConversionException
public HttpMessageConversionException HttpMessageConversionException(String msg, @Nullable Throwable cause)
{
    super(msg, cause);
}
 HttpMessageConverter
 HttpMessageNotReadableException
 extends HttpMessageConversionException
org.springframework.http.converter.HttpMessageNotReadableException
@Deprecated public HttpMessageNotReadableException HttpMessageNotReadableException(String msg)
{
    super(msg);
    this.httpInputMessage = null;
}
org.springframework.http.converter.HttpMessageNotReadableException
@Deprecated public HttpMessageNotReadableException HttpMessageNotReadableException(String msg, @Nullable Throwable cause)
{
    super(msg, cause);
    this.httpInputMessage = null;
}
org.springframework.http.converter.HttpMessageNotReadableException
public HttpMessageNotReadableException HttpMessageNotReadableException(String msg, HttpInputMessage httpInputMessage)
{
    super(msg);
    this.httpInputMessage = httpInputMessage;
}
org.springframework.http.converter.HttpMessageNotReadableException
public HttpMessageNotReadableException HttpMessageNotReadableException(String msg, @Nullable Throwable cause, HttpInputMessage httpInputMessage)
{
    super(msg, cause);
    this.httpInputMessage = httpInputMessage;
}
org.springframework.http.converter.HttpMessageNotReadableException
public HttpInputMessage getHttpInputMessage()
{
    Assert.state(this.httpInputMessage != null, "No HttpInputMessage available - use non-deprecated constructors");
    return this.httpInputMessage;
}
 HttpMessageNotWritableException
 extends HttpMessageConversionException
org.springframework.http.converter.HttpMessageNotWritableException
public HttpMessageNotWritableException HttpMessageNotWritableException(String msg)
{
    super(msg);
}
org.springframework.http.converter.HttpMessageNotWritableException
public HttpMessageNotWritableException HttpMessageNotWritableException(String msg, @Nullable Throwable cause)
{
    super(msg, cause);
}
 ObjectToStringHttpMessageConverter
 extends AbstractHttpMessageConverter<Object>
org.springframework.http.converter.ObjectToStringHttpMessageConverter
public ObjectToStringHttpMessageConverter ObjectToStringHttpMessageConverter(ConversionService conversionService)
{
    this(conversionService, StringHttpMessageConverter.DEFAULT_CHARSET);
}
org.springframework.http.converter.ObjectToStringHttpMessageConverter
public ObjectToStringHttpMessageConverter ObjectToStringHttpMessageConverter(ConversionService conversionService, Charset defaultCharset)
{
    super(defaultCharset, MediaType.TEXT_PLAIN);
    Assert.notNull(conversionService, "ConversionService is required");
    this.conversionService = conversionService;
    this.stringHttpMessageConverter = new StringHttpMessageConverter(defaultCharset);
}
org.springframework.http.converter.ObjectToStringHttpMessageConverter
@Override public boolean canRead(Class<?> clazz, @Nullable MediaType mediaType)
{
    return canRead(mediaType) && this.conversionService.canConvert(String.class, clazz);
}
org.springframework.http.converter.ObjectToStringHttpMessageConverter
@Override public boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType)
{
    return canWrite(mediaType) && this.conversionService.canConvert(clazz, String.class);
}
org.springframework.http.converter.ObjectToStringHttpMessageConverter
@Override protected Long getContentLength(Object obj, @Nullable MediaType contentType)
{
    String value = this.conversionService.convert(obj, String.class);
    if (value == null) {
        return 0L;
    } 
    return this.stringHttpMessageConverter.getContentLength(value, contentType);
}
org.springframework.http.converter.ObjectToStringHttpMessageConverter
public void setWriteAcceptCharset(boolean writeAcceptCharset)
{
    this.stringHttpMessageConverter.setWriteAcceptCharset(writeAcceptCharset);
}
org.springframework.http.converter.ObjectToStringHttpMessageConverter
@Override protected boolean supports(Class<?> clazz)
{
    throw new UnsupportedOperationException();
}
org.springframework.http.converter.ObjectToStringHttpMessageConverter
@Override protected void writeInternal(Object obj, HttpOutputMessage outputMessage)
{
    String value = this.conversionService.convert(obj, String.class);
    if (value != null) {
        this.stringHttpMessageConverter.writeInternal(value, outputMessage);
    } 
}
 ResourceHttpMessageConverter
 extends AbstractHttpMessageConverter<Resource>
org.springframework.http.converter.ResourceHttpMessageConverter
public ResourceHttpMessageConverter ResourceHttpMessageConverter()
{
    super(MediaType.ALL);
    this.supportsReadStreaming = true;
}
org.springframework.http.converter.ResourceHttpMessageConverter
public ResourceHttpMessageConverter ResourceHttpMessageConverter(boolean supportsReadStreaming)
{
    super(MediaType.ALL);
    this.supportsReadStreaming = supportsReadStreaming;
}
org.springframework.http.converter.ResourceHttpMessageConverter
@Override protected Long getContentLength(Resource resource, @Nullable MediaType contentType)
{
    if (InputStreamResource.class == resource.getClass()) {
        return null;
    } 
    long contentLength = resource.contentLength();
    return (contentLength < 0 ? null : contentLength);
}
org.springframework.http.converter.ResourceHttpMessageConverter
@Override protected MediaType getDefaultContentType(Resource resource)
{
    return MediaTypeFactory.getMediaType(resource).orElse(MediaType.APPLICATION_OCTET_STREAM);
}
org.springframework.http.converter.ResourceHttpMessageConverter
@Override protected boolean supports(Class<?> clazz)
{
    return Resource.class.isAssignableFrom(clazz);
}
org.springframework.http.converter.ResourceHttpMessageConverter
protected void writeContent(Resource resource, HttpOutputMessage outputMessage)
{
    try {
        InputStream in = resource.getInputStream();
        try {
            StreamUtils.copy(in, outputMessage.getBody());
        } catch (NullPointerException ex) {
        } finally {
            try {
                in.close();
            } catch (Throwable ex) {
            }
        }
    } catch (FileNotFoundException ex) {
    }
}
org.springframework.http.converter.ResourceHttpMessageConverter
@Override protected void writeInternal(Resource resource, HttpOutputMessage outputMessage)
{
    writeContent(resource, outputMessage);
}
 ResourceRegionHttpMessageConverter
 extends AbstractGenericHttpMessageConverter<Object>
org.springframework.http.converter.ResourceRegionHttpMessageConverter
public ResourceRegionHttpMessageConverter ResourceRegionHttpMessageConverter()
{
    super(MediaType.ALL);
}
org.springframework.http.converter.ResourceRegionHttpMessageConverter
@Override public boolean canRead(Class<?> clazz, @Nullable MediaType mediaType)
{
    return false;
}
org.springframework.http.converter.ResourceRegionHttpMessageConverter
@Override public boolean canRead(Type type, @Nullable Class<?> contextClass, @Nullable MediaType mediaType)
{
    return false;
}
org.springframework.http.converter.ResourceRegionHttpMessageConverter
@Override public boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType)
{
    return canWrite(clazz, null, mediaType);
}
org.springframework.http.converter.ResourceRegionHttpMessageConverter
@Override public boolean canWrite(@Nullable Type type, @Nullable Class<?> clazz, @Nullable MediaType mediaType)
{
    if (!(type instanceof ParameterizedType)) {
        return (type instanceof Class && ResourceRegion.class.isAssignableFrom((Class<?>)type));
    } 
    ParameterizedType parameterizedType = (ParameterizedType)type;
    if (!(parameterizedType.getRawType() instanceof Class)) {
        return false;
    } 
    Class<?> rawType = (Class<?>)parameterizedType.getRawType();
    if (!(Collection.class.isAssignableFrom(rawType))) {
        return false;
    } 
    if (parameterizedType.getActualTypeArguments().length != 1) {
        return false;
    } 
    Type typeArgument = parameterizedType.getActualTypeArguments()[0];
    if (!(typeArgument instanceof Class)) {
        return false;
    } 
    Class<?> typeArgumentClass = (Class<?>)typeArgument;
    return ResourceRegion.class.isAssignableFrom(typeArgumentClass);
}
org.springframework.http.converter.ResourceRegionHttpMessageConverter
@Override @SuppressWarnings("unchecked") protected MediaType getDefaultContentType(Object object)
{
    Resource resource = null;
    if (object instanceof ResourceRegion) {
        resource = ((ResourceRegion)object).getResource();
    } else {
        Collection<ResourceRegion> regions = (Collection<ResourceRegion>)object;
        if (!regions.isEmpty()) {
            resource = regions.iterator().next().getResource();
        } 
    }
    return MediaTypeFactory.getMediaType(resource).orElse(MediaType.APPLICATION_OCTET_STREAM);
}
org.springframework.http.converter.ResourceRegionHttpMessageConverter
@Override public Object read(Type type, @Nullable Class<?> contextClass, HttpInputMessage inputMessage)
{
    throw new UnsupportedOperationException();
}
org.springframework.http.converter.ResourceRegionHttpMessageConverter
@Override protected ResourceRegion readInternal(Class<?> clazz, HttpInputMessage inputMessage)
{
    throw new UnsupportedOperationException();
}
 StringHttpMessageConverter
 extends AbstractHttpMessageConverter<String>
org.springframework.http.converter.StringHttpMessageConverter
public static final Charset DEFAULT_CHARSET
org.springframework.http.converter.StringHttpMessageConverter
public StringHttpMessageConverter StringHttpMessageConverter()
{
    this(DEFAULT_CHARSET);
}
org.springframework.http.converter.StringHttpMessageConverter
public StringHttpMessageConverter StringHttpMessageConverter(Charset defaultCharset)
{
    super(defaultCharset, MediaType.TEXT_PLAIN, MediaType.ALL);
}
org.springframework.http.converter.StringHttpMessageConverter
@Nullable volatile List<Charset> availableCharsets
org.springframework.http.converter.StringHttpMessageConverter
protected List<Charset> getAcceptedCharsets()
{
    List<Charset> charsets = this.availableCharsets;
    if (charsets == null) {
        charsets = new ArrayList<>(Charset.availableCharsets().values());
        this.availableCharsets = charsets;
    } 
    return charsets;
}
org.springframework.http.converter.StringHttpMessageConverter
@Override protected Long getContentLength(String str, @Nullable MediaType contentType)
{
    Charset charset = getContentTypeCharset(contentType);
    return (long)str.getBytes(charset).length;
}
org.springframework.http.converter.StringHttpMessageConverter
@Override protected String readInternal(Class<?> clazz, HttpInputMessage inputMessage)
{
    Charset charset = getContentTypeCharset(inputMessage.getHeaders().getContentType());
    return StreamUtils.copyToString(inputMessage.getBody(), charset);
}
org.springframework.http.converter.StringHttpMessageConverter
public void setWriteAcceptCharset(boolean writeAcceptCharset)
{
    this.writeAcceptCharset = writeAcceptCharset;
}
org.springframework.http.converter.StringHttpMessageConverter
@Override public boolean supports(Class<?> clazz)
{
    return String.class == clazz;
}
org.springframework.http.converter.StringHttpMessageConverter
@Override protected void writeInternal(String str, HttpOutputMessage outputMessage)
{
    HttpHeaders headers = outputMessage.getHeaders();
    if (this.writeAcceptCharset && headers.get(HttpHeaders.ACCEPT_CHARSET) == null) {
        headers.setAcceptCharset(getAcceptedCharsets());
    } 
    Charset charset = getContentTypeCharset(headers.getContentType());
    StreamUtils.copy(str, charset, outputMessage.getBody());
}
 MappingJackson2CborHttpMessageConverter
 extends AbstractJackson2HttpMessageConverter
org.springframework.http.converter.cbor.MappingJackson2CborHttpMessageConverter
public MappingJackson2CborHttpMessageConverter MappingJackson2CborHttpMessageConverter()
{
    this(Jackson2ObjectMapperBuilder.cbor().build());
}
org.springframework.http.converter.cbor.MappingJackson2CborHttpMessageConverter
public MappingJackson2CborHttpMessageConverter MappingJackson2CborHttpMessageConverter(ObjectMapper objectMapper)
{
    super(objectMapper, MediaType.APPLICATION_CBOR);
    Assert.isInstanceOf(CBORFactory.class, objectMapper.getFactory(), "CBORFactory required");
}
org.springframework.http.converter.cbor.MappingJackson2CborHttpMessageConverter
@Override public void setObjectMapper(ObjectMapper objectMapper)
{
    Assert.isInstanceOf(CBORFactory.class, objectMapper.getFactory(), "CBORFactory required");
    super.setObjectMapper(objectMapper);
}
 AbstractWireFeedHttpMessageConverter<T>
 extends AbstractHttpMessageConverter<T>
org.springframework.http.converter.feed.AbstractWireFeedHttpMessageConverter
protected AbstractWireFeedHttpMessageConverter AbstractWireFeedHttpMessageConverter(MediaType supportedMediaType)
{
    super(supportedMediaType);
}
org.springframework.http.converter.feed.AbstractWireFeedHttpMessageConverter
public static final Charset DEFAULT_CHARSET
 AtomFeedHttpMessageConverter
 extends AbstractWireFeedHttpMessageConverter<Feed>
org.springframework.http.converter.feed.AtomFeedHttpMessageConverter
public AtomFeedHttpMessageConverter AtomFeedHttpMessageConverter()
{
    super(new MediaType("application", "atom+xml"));
}
org.springframework.http.converter.feed.AtomFeedHttpMessageConverter
@Override protected boolean supports(Class<?> clazz)
{
    return Feed.class.isAssignableFrom(clazz);
}
 RssChannelHttpMessageConverter
 extends AbstractWireFeedHttpMessageConverter<Channel>
org.springframework.http.converter.feed.RssChannelHttpMessageConverter
public RssChannelHttpMessageConverter RssChannelHttpMessageConverter()
{
    super(MediaType.APPLICATION_RSS_XML);
}
org.springframework.http.converter.feed.RssChannelHttpMessageConverter
@Override protected boolean supports(Class<?> clazz)
{
    return Channel.class.isAssignableFrom(clazz);
}
 AbstractJackson2HttpMessageConverter
 extends AbstractGenericHttpMessageConverter<Object>
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter
protected AbstractJackson2HttpMessageConverter AbstractJackson2HttpMessageConverter(ObjectMapper objectMapper)
{
    this.objectMapper = objectMapper;
    DefaultPrettyPrinter prettyPrinter = new DefaultPrettyPrinter();
    prettyPrinter.indentObjectsWith(new DefaultIndenter("  ", "\ndata:"));
    this.ssePrettyPrinter = prettyPrinter;
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter
protected AbstractJackson2HttpMessageConverter AbstractJackson2HttpMessageConverter(ObjectMapper objectMapper, MediaType supportedMediaType)
{
    this(objectMapper);
    setSupportedMediaTypes(Collections.singletonList(supportedMediaType));
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter
protected AbstractJackson2HttpMessageConverter AbstractJackson2HttpMessageConverter(ObjectMapper objectMapper, MediaType... supportedMediaTypes)
{
    this(objectMapper);
    setSupportedMediaTypes(Arrays.asList(supportedMediaTypes));
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter
@Nullable @Deprecated public static final Charset DEFAULT_CHARSET
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter
@Override public boolean canRead(Class<?> clazz, @Nullable MediaType mediaType)
{
    return canRead(clazz, null, mediaType);
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter
@Override public boolean canRead(Type type, @Nullable Class<?> contextClass, @Nullable MediaType mediaType)
{
    if (!canRead(mediaType)) {
        return false;
    } 
    JavaType javaType = getJavaType(type, contextClass);
    AtomicReference<Throwable> causeRef = new AtomicReference<>();
    if (this.objectMapper.canDeserialize(javaType, causeRef)) {
        return true;
    } 
    logWarningIfNecessary(javaType, causeRef.get());
    return false;
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter
@Override public boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType)
{
    if (!canWrite(mediaType)) {
        return false;
    } 
    AtomicReference<Throwable> causeRef = new AtomicReference<>();
    if (this.objectMapper.canSerialize(clazz, causeRef)) {
        return true;
    } 
    logWarningIfNecessary(clazz, causeRef.get());
    return false;
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter
@Override protected Long getContentLength(Object object, @Nullable MediaType contentType)
{
    if (object instanceof MappingJacksonValue) {
        object = ((MappingJacksonValue)object).getValue();
    } 
    return super.getContentLength(object, contentType);
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter
@Override @Nullable protected MediaType getDefaultContentType(Object object)
{
    if (object instanceof MappingJacksonValue) {
        object = ((MappingJacksonValue)object).getValue();
    } 
    return super.getDefaultContentType(object);
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter
protected JavaType getJavaType(Type type, @Nullable Class<?> contextClass)
{
    TypeFactory typeFactory = this.objectMapper.getTypeFactory();
    return typeFactory.constructType(GenericTypeResolver.resolveType(type, contextClass));
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter
protected JsonEncoding getJsonEncoding(@Nullable MediaType contentType)
{
    if (contentType != null && contentType.getCharset() != null) {
        Charset charset = contentType.getCharset();
        for (JsonEncoding encoding: JsonEncoding.values()) {
            if (charset.name().equals(encoding.getJavaName())) {
                return encoding;
            } 
        }
    } 
    return JsonEncoding.UTF8;
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter
public ObjectMapper getObjectMapper()
{
    return this.objectMapper;
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter
protected void logWarningIfNecessary(Type type, @Nullable Throwable cause)
{
    if (cause == null) {
        return ;
    } 
    boolean debugLevel = (cause instanceof JsonMappingException && cause.getMessage().startsWith("Cannot find"));
    if (debugLevel ? logger.isDebugEnabled() : logger.isWarnEnabled()) {
        String msg = "Failed to evaluate Jackson " + (type instanceof JavaType ? "de" : "") + "serialization for type [" + type + "]";
        if (debugLevel) {
            logger.debug(msg, cause);
        } else if (logger.isDebugEnabled()) {
            logger.warn(msg, cause);
        } else {
            logger.warn(msg + ": " + cause);
        }
    } 
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter
protected ObjectMapper objectMapper
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter
@Override public Object read(Type type, @Nullable Class<?> contextClass, HttpInputMessage inputMessage)
{
    JavaType javaType = getJavaType(type, contextClass);
    return readJavaType(javaType, inputMessage);
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter
@Override protected Object readInternal(Class<?> clazz, HttpInputMessage inputMessage)
{
    JavaType javaType = getJavaType(clazz, null);
    return readJavaType(javaType, inputMessage);
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter
public void setObjectMapper(ObjectMapper objectMapper)
{
    Assert.notNull(objectMapper, "ObjectMapper must not be null");
    this.objectMapper = objectMapper;
    configurePrettyPrint();
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter
public void setPrettyPrint(boolean prettyPrint)
{
    this.prettyPrint = prettyPrint;
    configurePrettyPrint();
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter
@Override protected void writeInternal(Object object, @Nullable Type type, HttpOutputMessage outputMessage)
{
    MediaType contentType = outputMessage.getHeaders().getContentType();
    JsonEncoding encoding = getJsonEncoding(contentType);
    JsonGenerator generator = this.objectMapper.getFactory().createGenerator(outputMessage.getBody(), encoding);
    try {
        writePrefix(generator, object);
        Object value = object;
        Class<?> serializationView = null;
        FilterProvider filters = null;
        JavaType javaType = null;
        if (object instanceof MappingJacksonValue) {
            MappingJacksonValue container = (MappingJacksonValue)object;
            value = container.getValue();
            serializationView = container.getSerializationView();
            filters = container.getFilters();
        } 
        if (type != null && TypeUtils.isAssignable(type, value.getClass())) {
            javaType = getJavaType(type, null);
        } 
        ObjectWriter objectWriter = (serializationView != null ? this.objectMapper.writerWithView(serializationView) : this.objectMapper.writer());
        if (filters != null) {
            objectWriter = objectWriter.with(filters);
        } 
        if (javaType != null && javaType.isContainerType()) {
            objectWriter = objectWriter.forType(javaType);
        } 
        SerializationConfig config = objectWriter.getConfig();
        if (contentType != null && contentType.isCompatibleWith(MediaType.TEXT_EVENT_STREAM) && config.isEnabled(SerializationFeature.INDENT_OUTPUT)) {
            objectWriter = objectWriter.with(this.ssePrettyPrinter);
        } 
        objectWriter.writeValue(generator, value);
        writeSuffix(generator, object);
        generator.flush();
    } catch (InvalidDefinitionException ex) {
        throw new HttpMessageConversionException("Type definition error: " + ex.getType(), ex);
    } catch (JsonProcessingException ex) {
        throw new HttpMessageNotWritableException("Could not write JSON: " + ex.getOriginalMessage(), ex);
    }
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter
protected void writePrefix(JsonGenerator generator, Object object)
{
}
org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter
protected void writeSuffix(JsonGenerator generator, Object object)
{
}
 AbstractJsonHttpMessageConverter
 extends AbstractGenericHttpMessageConverter<Object>
org.springframework.http.converter.json.AbstractJsonHttpMessageConverter
public AbstractJsonHttpMessageConverter AbstractJsonHttpMessageConverter()
{
    super(MediaType.APPLICATION_JSON, new MediaType("application", "*+json"));
    setDefaultCharset(DEFAULT_CHARSET);
}
org.springframework.http.converter.json.AbstractJsonHttpMessageConverter
public static final Charset DEFAULT_CHARSET
org.springframework.http.converter.json.AbstractJsonHttpMessageConverter
@Override public final Object read(Type type, @Nullable Class<?> contextClass, HttpInputMessage inputMessage)
{
    return readResolved(GenericTypeResolver.resolveType(type, contextClass), inputMessage);
}
org.springframework.http.converter.json.AbstractJsonHttpMessageConverter
@Override protected final Object readInternal(Class<?> clazz, HttpInputMessage inputMessage)
{
    return readResolved(clazz, inputMessage);
}
org.springframework.http.converter.json.AbstractJsonHttpMessageConverter
protected abstract Object readInternal(Type resolvedType, Reader reader)
org.springframework.http.converter.json.AbstractJsonHttpMessageConverter
public void setJsonPrefix(String jsonPrefix)
{
    this.jsonPrefix = jsonPrefix;
}
org.springframework.http.converter.json.AbstractJsonHttpMessageConverter
public void setPrefixJson(boolean prefixJson)
{
    this.jsonPrefix = (prefixJson ? ")]}', " : null);
}
org.springframework.http.converter.json.AbstractJsonHttpMessageConverter
@Override protected final void writeInternal(Object o, @Nullable Type type, HttpOutputMessage outputMessage)
{
    Writer writer = getWriter(outputMessage);
    if (this.jsonPrefix != null) {
        writer.append(this.jsonPrefix);
    } 
    try {
        writeInternal(o, type, writer);
    } catch (Exception ex) {
        throw new HttpMessageNotWritableException("Could not write JSON: " + ex.getMessage(), ex);
    }
    writer.flush();
}
org.springframework.http.converter.json.AbstractJsonHttpMessageConverter
protected abstract void writeInternal(Object o, @Nullable Type type, Writer writer)
 GsonBuilderUtils
org.springframework.http.converter.json.GsonBuilderUtils
public static GsonBuilder gsonBuilderWithBase64EncodedByteArrays()
{
    GsonBuilder builder = new GsonBuilder();
    builder.registerTypeHierarchyAdapter(byte[].class, new Base64TypeAdapter());
    return builder;
}
 GsonFactoryBean
 implements FactoryBean<Gson>, InitializingBean
org.springframework.http.converter.json.GsonFactoryBean
@Override public void afterPropertiesSet()
{
    GsonBuilder builder = (this.base64EncodeByteArrays ? GsonBuilderUtils.gsonBuilderWithBase64EncodedByteArrays() : new GsonBuilder());
    if (this.serializeNulls) {
        builder.serializeNulls();
    } 
    if (this.prettyPrinting) {
        builder.setPrettyPrinting();
    } 
    if (this.disableHtmlEscaping) {
        builder.disableHtmlEscaping();
    } 
    if (this.dateFormatPattern != null) {
        builder.setDateFormat(this.dateFormatPattern);
    } 
    this.gson = builder.create();
}
org.springframework.http.converter.json.GsonFactoryBean
@Override @Nullable public Gson getObject()
{
    return this.gson;
}
org.springframework.http.converter.json.GsonFactoryBean
@Override public Class<?> getObjectType()
{
    return Gson.class;
}
org.springframework.http.converter.json.GsonFactoryBean
@Override public boolean isSingleton()
{
    return true;
}
org.springframework.http.converter.json.GsonFactoryBean
public void setBase64EncodeByteArrays(boolean base64EncodeByteArrays)
{
    this.base64EncodeByteArrays = base64EncodeByteArrays;
}
org.springframework.http.converter.json.GsonFactoryBean
public void setDateFormatPattern(String dateFormatPattern)
{
    this.dateFormatPattern = dateFormatPattern;
}
org.springframework.http.converter.json.GsonFactoryBean
public void setDisableHtmlEscaping(boolean disableHtmlEscaping)
{
    this.disableHtmlEscaping = disableHtmlEscaping;
}
org.springframework.http.converter.json.GsonFactoryBean
public void setPrettyPrinting(boolean prettyPrinting)
{
    this.prettyPrinting = prettyPrinting;
}
org.springframework.http.converter.json.GsonFactoryBean
public void setSerializeNulls(boolean serializeNulls)
{
    this.serializeNulls = serializeNulls;
}
 GsonHttpMessageConverter
 extends AbstractJsonHttpMessageConverter
org.springframework.http.converter.json.GsonHttpMessageConverter
public GsonHttpMessageConverter GsonHttpMessageConverter()
{
    this.gson = new Gson();
}
org.springframework.http.converter.json.GsonHttpMessageConverter
public GsonHttpMessageConverter GsonHttpMessageConverter(Gson gson)
{
    Assert.notNull(gson, "A Gson instance is required");
    this.gson = gson;
}
org.springframework.http.converter.json.GsonHttpMessageConverter
public Gson getGson()
{
    return this.gson;
}
org.springframework.http.converter.json.GsonHttpMessageConverter
@Override protected Object readInternal(Type resolvedType, Reader reader)
{
    return getGson().fromJson(reader, resolvedType);
}
org.springframework.http.converter.json.GsonHttpMessageConverter
public void setGson(Gson gson)
{
    Assert.notNull(gson, "A Gson instance is required");
    this.gson = gson;
}
org.springframework.http.converter.json.GsonHttpMessageConverter
@Override protected void writeInternal(Object o, @Nullable Type type, Writer writer)
{
    if (type instanceof ParameterizedType) {
        getGson().toJson(o, type, writer);
    } else {
        getGson().toJson(o, writer);
    }
}
 Jackson2ObjectMapperBuilder
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder annotationIntrospector(AnnotationIntrospector annotationIntrospector)
{
    this.annotationIntrospector = annotationIntrospector;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder applicationContext(ApplicationContext applicationContext)
{
    this.applicationContext = applicationContext;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder autoDetectFields(boolean autoDetectFields)
{
    this.features.put(MapperFeature.AUTO_DETECT_FIELDS, autoDetectFields);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public static Jackson2ObjectMapperBuilder cbor()
{
    return new Jackson2ObjectMapperBuilder().factory(new CborFactoryInitializer().create());
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public void configure(ObjectMapper objectMapper)
{
    Assert.notNull(objectMapper, "ObjectMapper must not be null");
    MultiValueMap<Object, Module> modulesToRegister = new LinkedMultiValueMap<>();
    if (this.findModulesViaServiceLoader) {
        ObjectMapper.findModules(this.moduleClassLoader).forEach(module -> registerModule(module, modulesToRegister));
    } else if (this.findWellKnownModules) {
        registerWellKnownModulesIfAvailable(modulesToRegister);
    } 
    if (this.modules != null) {
        this.modules.forEach(module -> registerModule(module, modulesToRegister));
    } 
    if (this.moduleClasses != null) {
        for (Class<? extends Module> moduleClass: this.moduleClasses) {
            registerModule(BeanUtils.instantiateClass(moduleClass), modulesToRegister);
        }
    } 
    List<Module> modules = new ArrayList<>();
    for (List<Module> nestedModules: modulesToRegister.values()) {
        modules.addAll(nestedModules);
    }
    objectMapper.registerModules(modules);
    if (this.dateFormat != null) {
        objectMapper.setDateFormat(this.dateFormat);
    } 
    if (this.locale != null) {
        objectMapper.setLocale(this.locale);
    } 
    if (this.timeZone != null) {
        objectMapper.setTimeZone(this.timeZone);
    } 
    if (this.annotationIntrospector != null) {
        objectMapper.setAnnotationIntrospector(this.annotationIntrospector);
    } 
    if (this.propertyNamingStrategy != null) {
        objectMapper.setPropertyNamingStrategy(this.propertyNamingStrategy);
    } 
    if (this.defaultTyping != null) {
        objectMapper.setDefaultTyping(this.defaultTyping);
    } 
    if (this.serializationInclusion != null) {
        objectMapper.setSerializationInclusion(this.serializationInclusion);
    } 
    if (this.filters != null) {
        objectMapper.setFilterProvider(this.filters);
    } 
    this.mixIns.forEach(objectMapper::addMixIn);
    if (!this.serializers.isEmpty() || !this.deserializers.isEmpty()) {
        SimpleModule module = new SimpleModule();
        addSerializers(module);
        addDeserializers(module);
        objectMapper.registerModule(module);
    } 
    this.visibilities.forEach(objectMapper::setVisibility);
    customizeDefaultFeatures(objectMapper);
    this.features.forEach((feature, enabled) -> configureFeature(objectMapper, feature, enabled));
    if (this.handlerInstantiator != null) {
        objectMapper.setHandlerInstantiator(this.handlerInstantiator);
    } else if (this.applicationContext != null) {
        objectMapper.setHandlerInstantiator(new SpringHandlerInstantiator(this.applicationContext.getAutowireCapableBeanFactory()));
    } 
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder createXmlMapper(boolean createXmlMapper)
{
    this.createXmlMapper = createXmlMapper;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder dateFormat(DateFormat dateFormat)
{
    this.dateFormat = dateFormat;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder defaultTyping(TypeResolverBuilder<?> typeResolverBuilder)
{
    this.defaultTyping = typeResolverBuilder;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder defaultUseWrapper(boolean defaultUseWrapper)
{
    this.defaultUseWrapper = defaultUseWrapper;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder defaultViewInclusion(boolean defaultViewInclusion)
{
    this.features.put(MapperFeature.DEFAULT_VIEW_INCLUSION, defaultViewInclusion);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder deserializerByType(Class<?> type, JsonDeserializer<?> deserializer)
{
    this.deserializers.put(type, deserializer);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder deserializers(JsonDeserializer<?>... deserializers)
{
    for (JsonDeserializer<?> deserializer: deserializers) {
        Class<?> handledType = deserializer.handledType();
        if (handledType == null || handledType == Object.class) {
            throw new IllegalArgumentException("Unknown handled type in " + deserializer.getClass().getName());
        } 
        this.deserializers.put(deserializer.handledType(), deserializer);
    }
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder deserializersByType(Map<Class<?>, JsonDeserializer<?>> deserializers)
{
    this.deserializers.putAll(deserializers);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder factory(JsonFactory factory)
{
    this.factory = factory;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder failOnEmptyBeans(boolean failOnEmptyBeans)
{
    this.features.put(SerializationFeature.FAIL_ON_EMPTY_BEANS, failOnEmptyBeans);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder failOnUnknownProperties(boolean failOnUnknownProperties)
{
    this.features.put(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, failOnUnknownProperties);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder featuresToDisable(Object... featuresToDisable)
{
    for (Object feature: featuresToDisable) {
        this.features.put(feature, Boolean.FALSE);
    }
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder featuresToEnable(Object... featuresToEnable)
{
    for (Object feature: featuresToEnable) {
        this.features.put(feature, Boolean.TRUE);
    }
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder filters(FilterProvider filters)
{
    this.filters = filters;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder findModulesViaServiceLoader(boolean findModules)
{
    this.findModulesViaServiceLoader = findModules;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder handlerInstantiator(HandlerInstantiator handlerInstantiator)
{
    this.handlerInstantiator = handlerInstantiator;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder indentOutput(boolean indentOutput)
{
    this.features.put(SerializationFeature.INDENT_OUTPUT, indentOutput);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public static Jackson2ObjectMapperBuilder json()
{
    return new Jackson2ObjectMapperBuilder();
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
volatile static boolean kotlinWarningLogged
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder locale(Locale locale)
{
    this.locale = locale;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder locale(String localeString)
{
    this.locale = StringUtils.parseLocale(localeString);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder mixIn(Class<?> target, Class<?> mixinSource)
{
    this.mixIns.put(target, mixinSource);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder mixIns(Map<Class<?>, Class<?>> mixIns)
{
    this.mixIns.putAll(mixIns);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder moduleClassLoader(ClassLoader moduleClassLoader)
{
    this.moduleClassLoader = moduleClassLoader;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder modules(Module... modules)
{
    return modules(Arrays.asList(modules));
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder modules(List<Module> modules)
{
    this.modules = new LinkedList<>(modules);
    this.findModulesViaServiceLoader = false;
    this.findWellKnownModules = false;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder modulesToInstall(Module... modules)
{
    this.modules = Arrays.asList(modules);
    this.findWellKnownModules = true;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
@SuppressWarnings("unchecked") public Jackson2ObjectMapperBuilder modulesToInstall(Class<?>... modules)
{
    this.moduleClasses = modules;
    this.findWellKnownModules = true;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder propertyNamingStrategy(PropertyNamingStrategy propertyNamingStrategy)
{
    this.propertyNamingStrategy = propertyNamingStrategy;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder serializationInclusion(JsonInclude.Include serializationInclusion)
{
    this.serializationInclusion = serializationInclusion;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder serializerByType(Class<?> type, JsonSerializer<?> serializer)
{
    this.serializers.put(type, serializer);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder serializers(JsonSerializer<?>... serializers)
{
    for (JsonSerializer<?> serializer: serializers) {
        Class<?> handledType = serializer.handledType();
        if (handledType == null || handledType == Object.class) {
            throw new IllegalArgumentException("Unknown handled type in " + serializer.getClass().getName());
        } 
        this.serializers.put(serializer.handledType(), serializer);
    }
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder serializersByType(Map<Class<?>, JsonSerializer<?>> serializers)
{
    this.serializers.putAll(serializers);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder simpleDateFormat(String format)
{
    this.dateFormat = new SimpleDateFormat(format);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public static Jackson2ObjectMapperBuilder smile()
{
    return new Jackson2ObjectMapperBuilder().factory(new SmileFactoryInitializer().create());
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder timeZone(TimeZone timeZone)
{
    this.timeZone = timeZone;
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder timeZone(String timeZoneString)
{
    this.timeZone = StringUtils.parseTimeZoneString(timeZoneString);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public Jackson2ObjectMapperBuilder visibility(PropertyAccessor accessor, JsonAutoDetect.Visibility visibility)
{
    this.visibilities.put(accessor, visibility);
    return this;
}
org.springframework.http.converter.json.Jackson2ObjectMapperBuilder
public static Jackson2ObjectMapperBuilder xml()
{
    return new Jackson2ObjectMapperBuilder().createXmlMapper(true);
}
 Jackson2ObjectMapperFactoryBean
 implements FactoryBean<ObjectMapper>, BeanClassLoaderAware, ApplicationContextAware, InitializingBean
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
@Override public void afterPropertiesSet()
{
    if (this.objectMapper != null) {
        this.builder.configure(this.objectMapper);
    } else {
        this.objectMapper = this.builder.build();
    }
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
@Override @Nullable public ObjectMapper getObject()
{
    return this.objectMapper;
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
@Override public Class<?> getObjectType()
{
    return (this.objectMapper != null ? this.objectMapper.getClass() : null);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
@Override public boolean isSingleton()
{
    return true;
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setAnnotationIntrospector(AnnotationIntrospector annotationIntrospector)
{
    this.builder.annotationIntrospector(annotationIntrospector);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
@Override public void setApplicationContext(ApplicationContext applicationContext)
{
    this.builder.applicationContext(applicationContext);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setAutoDetectFields(boolean autoDetectFields)
{
    this.builder.autoDetectFields(autoDetectFields);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setAutoDetectGettersSetters(boolean autoDetectGettersSetters)
{
    this.builder.autoDetectGettersSetters(autoDetectGettersSetters);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
@Override public void setBeanClassLoader(ClassLoader beanClassLoader)
{
    this.builder.moduleClassLoader(beanClassLoader);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setCreateXmlMapper(boolean createXmlMapper)
{
    this.builder.createXmlMapper(createXmlMapper);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setDateFormat(DateFormat dateFormat)
{
    this.builder.dateFormat(dateFormat);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setDefaultTyping(TypeResolverBuilder<?> typeResolverBuilder)
{
    this.builder.defaultTyping(typeResolverBuilder);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setDefaultUseWrapper(boolean defaultUseWrapper)
{
    this.builder.defaultUseWrapper(defaultUseWrapper);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setDefaultViewInclusion(boolean defaultViewInclusion)
{
    this.builder.defaultViewInclusion(defaultViewInclusion);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setDeserializers(JsonDeserializer<?>... deserializers)
{
    this.builder.deserializers(deserializers);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setDeserializersByType(Map<Class<?>, JsonDeserializer<?>> deserializers)
{
    this.builder.deserializersByType(deserializers);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setFactory(JsonFactory factory)
{
    this.builder.factory(factory);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setFailOnEmptyBeans(boolean failOnEmptyBeans)
{
    this.builder.failOnEmptyBeans(failOnEmptyBeans);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setFailOnUnknownProperties(boolean failOnUnknownProperties)
{
    this.builder.failOnUnknownProperties(failOnUnknownProperties);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setFeaturesToDisable(Object... featuresToDisable)
{
    this.builder.featuresToDisable(featuresToDisable);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setFeaturesToEnable(Object... featuresToEnable)
{
    this.builder.featuresToEnable(featuresToEnable);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setFilters(FilterProvider filters)
{
    this.builder.filters(filters);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setFindModulesViaServiceLoader(boolean findModules)
{
    this.builder.findModulesViaServiceLoader(findModules);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setHandlerInstantiator(HandlerInstantiator handlerInstantiator)
{
    this.builder.handlerInstantiator(handlerInstantiator);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setIndentOutput(boolean indentOutput)
{
    this.builder.indentOutput(indentOutput);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setLocale(Locale locale)
{
    this.builder.locale(locale);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setMixIns(Map<Class<?>, Class<?>> mixIns)
{
    this.builder.mixIns(mixIns);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setModules(List<Module> modules)
{
    this.builder.modules(modules);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
@SuppressWarnings("unchecked") public void setModulesToInstall(Class<?>... modules)
{
    this.builder.modulesToInstall(modules);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setObjectMapper(ObjectMapper objectMapper)
{
    this.objectMapper = objectMapper;
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setPropertyNamingStrategy(PropertyNamingStrategy propertyNamingStrategy)
{
    this.builder.propertyNamingStrategy(propertyNamingStrategy);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setSerializationInclusion(JsonInclude.Include serializationInclusion)
{
    this.builder.serializationInclusion(serializationInclusion);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setSerializers(JsonSerializer<?>... serializers)
{
    this.builder.serializers(serializers);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setSerializersByType(Map<Class<?>, JsonSerializer<?>> serializers)
{
    this.builder.serializersByType(serializers);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setSimpleDateFormat(String format)
{
    this.builder.simpleDateFormat(format);
}
org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean
public void setTimeZone(TimeZone timeZone)
{
    this.builder.timeZone(timeZone);
}
 JsonbHttpMessageConverter
 extends AbstractJsonHttpMessageConverter
org.springframework.http.converter.json.JsonbHttpMessageConverter
public JsonbHttpMessageConverter JsonbHttpMessageConverter()
{
    this(JsonbBuilder.create());
}
org.springframework.http.converter.json.JsonbHttpMessageConverter
public JsonbHttpMessageConverter JsonbHttpMessageConverter(JsonbConfig config)
{
    this.jsonb = JsonbBuilder.create(config);
}
org.springframework.http.converter.json.JsonbHttpMessageConverter
public JsonbHttpMessageConverter JsonbHttpMessageConverter(Jsonb jsonb)
{
    Assert.notNull(jsonb, "A Jsonb instance is required");
    this.jsonb = jsonb;
}
org.springframework.http.converter.json.JsonbHttpMessageConverter
public Jsonb getJsonb()
{
    return this.jsonb;
}
org.springframework.http.converter.json.JsonbHttpMessageConverter
@Override protected Object readInternal(Type resolvedType, Reader reader)
{
    return getJsonb().fromJson(reader, resolvedType);
}
org.springframework.http.converter.json.JsonbHttpMessageConverter
public void setJsonb(Jsonb jsonb)
{
    Assert.notNull(jsonb, "A Jsonb instance is required");
    this.jsonb = jsonb;
}
org.springframework.http.converter.json.JsonbHttpMessageConverter
@Override protected void writeInternal(Object o, @Nullable Type type, Writer writer)
{
    if (type instanceof ParameterizedType) {
        getJsonb().toJson(o, type, writer);
    } else {
        getJsonb().toJson(o, writer);
    }
}
 MappingJackson2HttpMessageConverter
 extends AbstractJackson2HttpMessageConverter
org.springframework.http.converter.json.MappingJackson2HttpMessageConverter
public MappingJackson2HttpMessageConverter MappingJackson2HttpMessageConverter()
{
    this(Jackson2ObjectMapperBuilder.json().build());
}
org.springframework.http.converter.json.MappingJackson2HttpMessageConverter
public MappingJackson2HttpMessageConverter MappingJackson2HttpMessageConverter(ObjectMapper objectMapper)
{
    super(objectMapper, MediaType.APPLICATION_JSON, new MediaType("application", "*+json"));
}
org.springframework.http.converter.json.MappingJackson2HttpMessageConverter
public void setJsonPrefix(String jsonPrefix)
{
    this.jsonPrefix = jsonPrefix;
}
org.springframework.http.converter.json.MappingJackson2HttpMessageConverter
public void setPrefixJson(boolean prefixJson)
{
    this.jsonPrefix = (prefixJson ? ")]}', " : null);
}
org.springframework.http.converter.json.MappingJackson2HttpMessageConverter
@Override protected void writePrefix(JsonGenerator generator, Object object)
{
    if (this.jsonPrefix != null) {
        generator.writeRaw(this.jsonPrefix);
    } 
}
 MappingJacksonInputMessage
 implements HttpInputMessage
org.springframework.http.converter.json.MappingJacksonInputMessage
public MappingJacksonInputMessage MappingJacksonInputMessage(InputStream body, HttpHeaders headers)
{
    this.body = body;
    this.headers = headers;
}
org.springframework.http.converter.json.MappingJacksonInputMessage
public MappingJacksonInputMessage MappingJacksonInputMessage(InputStream body, HttpHeaders headers, Class<?> deserializationView)
{
    this(body, headers);
    this.deserializationView = deserializationView;
}
org.springframework.http.converter.json.MappingJacksonInputMessage
@Override public InputStream getBody()
{
    return this.body;
}
org.springframework.http.converter.json.MappingJacksonInputMessage
@Nullable public Class<?> getDeserializationView()
{
    return this.deserializationView;
}
org.springframework.http.converter.json.MappingJacksonInputMessage
@Override public HttpHeaders getHeaders()
{
    return this.headers;
}
org.springframework.http.converter.json.MappingJacksonInputMessage
public void setDeserializationView(@Nullable Class<?> deserializationView)
{
    this.deserializationView = deserializationView;
}
 MappingJacksonValue
org.springframework.http.converter.json.MappingJacksonValue
public MappingJacksonValue MappingJacksonValue(Object value)
{
    this.value = value;
}
org.springframework.http.converter.json.MappingJacksonValue
@Nullable public FilterProvider getFilters()
{
    return this.filters;
}
org.springframework.http.converter.json.MappingJacksonValue
@Nullable public Class<?> getSerializationView()
{
    return this.serializationView;
}
org.springframework.http.converter.json.MappingJacksonValue
public Object getValue()
{
    return this.value;
}
org.springframework.http.converter.json.MappingJacksonValue
public void setFilters(@Nullable FilterProvider filters)
{
    this.filters = filters;
}
org.springframework.http.converter.json.MappingJacksonValue
public void setSerializationView(@Nullable Class<?> serializationView)
{
    this.serializationView = serializationView;
}
org.springframework.http.converter.json.MappingJacksonValue
public void setValue(Object value)
{
    this.value = value;
}
 SpringHandlerInstantiator
 extends HandlerInstantiator
org.springframework.http.converter.json.SpringHandlerInstantiator
public SpringHandlerInstantiator SpringHandlerInstantiator(AutowireCapableBeanFactory beanFactory)
{
    Assert.notNull(beanFactory, "BeanFactory must not be null");
    this.beanFactory = beanFactory;
}
org.springframework.http.converter.json.SpringHandlerInstantiator
@Override public Converter<?, ?> converterInstance(MapperConfig<?> config, Annotated annotated, Class<?> implClass)
{
    return (Converter<?, ?>)this.beanFactory.createBean(implClass);
}
org.springframework.http.converter.json.SpringHandlerInstantiator
@Override public JsonDeserializer<?> deserializerInstance(DeserializationConfig config, Annotated annotated, Class<?> implClass)
{
    return (JsonDeserializer<?>)this.beanFactory.createBean(implClass);
}
org.springframework.http.converter.json.SpringHandlerInstantiator
@Override public KeyDeserializer keyDeserializerInstance(DeserializationConfig config, Annotated annotated, Class<?> implClass)
{
    return (KeyDeserializer)this.beanFactory.createBean(implClass);
}
org.springframework.http.converter.json.SpringHandlerInstantiator
@Override public PropertyNamingStrategy namingStrategyInstance(MapperConfig<?> config, Annotated annotated, Class<?> implClass)
{
    return (PropertyNamingStrategy)this.beanFactory.createBean(implClass);
}
org.springframework.http.converter.json.SpringHandlerInstantiator
@Override public ObjectIdGenerator<?> objectIdGeneratorInstance(MapperConfig<?> config, Annotated annotated, Class<?> implClass)
{
    return (ObjectIdGenerator<?>)this.beanFactory.createBean(implClass);
}
org.springframework.http.converter.json.SpringHandlerInstantiator
@Override public ObjectIdResolver resolverIdGeneratorInstance(MapperConfig<?> config, Annotated annotated, Class<?> implClass)
{
    return (ObjectIdResolver)this.beanFactory.createBean(implClass);
}
org.springframework.http.converter.json.SpringHandlerInstantiator
@Override public JsonSerializer<?> serializerInstance(SerializationConfig config, Annotated annotated, Class<?> implClass)
{
    return (JsonSerializer<?>)this.beanFactory.createBean(implClass);
}
org.springframework.http.converter.json.SpringHandlerInstantiator
@Override public TypeIdResolver typeIdResolverInstance(MapperConfig<?> config, Annotated annotated, Class<?> implClass)
{
    return (TypeIdResolver)this.beanFactory.createBean(implClass);
}
org.springframework.http.converter.json.SpringHandlerInstantiator
@Override public TypeResolverBuilder<?> typeResolverBuilderInstance(MapperConfig<?> config, Annotated annotated, Class<?> implClass)
{
    return (TypeResolverBuilder<?>)this.beanFactory.createBean(implClass);
}
org.springframework.http.converter.json.SpringHandlerInstantiator
@Override public ValueInstantiator valueInstantiatorInstance(MapperConfig<?> config, Annotated annotated, Class<?> implClass)
{
    return (ValueInstantiator)this.beanFactory.createBean(implClass);
}
org.springframework.http.converter.json.SpringHandlerInstantiator
@Override public VirtualBeanPropertyWriter virtualPropertyWriterInstance(MapperConfig<?> config, Class<?> implClass)
{
    return (VirtualBeanPropertyWriter)this.beanFactory.createBean(implClass);
}
 ExtensionRegistryInitializer
 ProtobufHttpMessageConverter
 extends AbstractHttpMessageConverter<Message>
org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter
public static final Charset DEFAULT_CHARSET
org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter
public static final MediaType PROTOBUF
org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter
public ProtobufHttpMessageConverter ProtobufHttpMessageConverter()
{
    this(null, null);
}
org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter
@Deprecated public ProtobufHttpMessageConverter ProtobufHttpMessageConverter(@Nullable ExtensionRegistryInitializer registryInitializer)
{
    this(null, null);
    if (registryInitializer != null) {
        registryInitializer.initializeExtensionRegistry(this.extensionRegistry);
    } 
}
org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter
public ProtobufHttpMessageConverter ProtobufHttpMessageConverter(ExtensionRegistry extensionRegistry)
{
    this(null, extensionRegistry);
}
org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter
public static final String X_PROTOBUF_MESSAGE_HEADER
org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter
public static final String X_PROTOBUF_SCHEMA_HEADER
org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter
@Override protected boolean canWrite(@Nullable MediaType mediaType)
{
    return (super.canWrite(mediaType) || (this.protobufFormatSupport != null && this.protobufFormatSupport.supportsWriteOnly(mediaType)));
}
org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter
@Override protected MediaType getDefaultContentType(Message message)
{
    return PROTOBUF;
}
org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter
@Override protected Message readInternal(Class<?> clazz, HttpInputMessage inputMessage)
{
    MediaType contentType = inputMessage.getHeaders().getContentType();
    if (contentType == null) {
        contentType = PROTOBUF;
    } 
    Charset charset = contentType.getCharset();
    if (charset == null) {
        charset = DEFAULT_CHARSET;
    } 
    Message.Builder builder = getMessageBuilder(clazz);
    if (PROTOBUF.isCompatibleWith(contentType)) {
        builder.mergeFrom(inputMessage.getBody(), this.extensionRegistry);
    } else if (TEXT_PLAIN.isCompatibleWith(contentType)) {
        InputStreamReader reader = new InputStreamReader(inputMessage.getBody(), charset);
        TextFormat.merge(reader, this.extensionRegistry, builder);
    } else if (this.protobufFormatSupport != null) {
        this.protobufFormatSupport.merge(inputMessage.getBody(), charset, contentType, this.extensionRegistry, builder);
    } 
    return builder.build();
}
org.springframework.http.converter.protobuf.ProtobufHttpMessageConverter
@Override protected boolean supports(Class<?> clazz)
{
    return Message.class.isAssignableFrom(clazz);
}
 ProtobufJsonFormatHttpMessageConverter
 extends ProtobufHttpMessageConverter
org.springframework.http.converter.protobuf.ProtobufJsonFormatHttpMessageConverter
public ProtobufJsonFormatHttpMessageConverter ProtobufJsonFormatHttpMessageConverter()
{
    this(null, null, (ExtensionRegistry)null);
}
org.springframework.http.converter.protobuf.ProtobufJsonFormatHttpMessageConverter
public ProtobufJsonFormatHttpMessageConverter ProtobufJsonFormatHttpMessageConverter(@Nullable JsonFormat.Parser parser, @Nullable JsonFormat.Printer printer)
{
    this(parser, printer, (ExtensionRegistry)null);
}
org.springframework.http.converter.protobuf.ProtobufJsonFormatHttpMessageConverter
public ProtobufJsonFormatHttpMessageConverter ProtobufJsonFormatHttpMessageConverter(@Nullable JsonFormat.Parser parser, @Nullable JsonFormat.Printer printer, @Nullable ExtensionRegistry extensionRegistry)
{
    super(new ProtobufJavaUtilSupport(parser, printer), extensionRegistry);
}
org.springframework.http.converter.protobuf.ProtobufJsonFormatHttpMessageConverter
@Deprecated public ProtobufJsonFormatHttpMessageConverter ProtobufJsonFormatHttpMessageConverter(@Nullable JsonFormat.Parser parser, @Nullable JsonFormat.Printer printer, @Nullable ExtensionRegistryInitializer registryInitializer)
{
    super(new ProtobufJavaUtilSupport(parser, printer), null);
    if (registryInitializer != null) {
        registryInitializer.initializeExtensionRegistry(this.extensionRegistry);
    } 
}
 MappingJackson2SmileHttpMessageConverter
 extends AbstractJackson2HttpMessageConverter
org.springframework.http.converter.smile.MappingJackson2SmileHttpMessageConverter
public MappingJackson2SmileHttpMessageConverter MappingJackson2SmileHttpMessageConverter()
{
    this(Jackson2ObjectMapperBuilder.smile().build());
}
org.springframework.http.converter.smile.MappingJackson2SmileHttpMessageConverter
public MappingJackson2SmileHttpMessageConverter MappingJackson2SmileHttpMessageConverter(ObjectMapper objectMapper)
{
    super(objectMapper, new MediaType("application", "x-jackson-smile"));
    Assert.isInstanceOf(SmileFactory.class, objectMapper.getFactory(), "SmileFactory required");
}
org.springframework.http.converter.smile.MappingJackson2SmileHttpMessageConverter
@Override public void setObjectMapper(ObjectMapper objectMapper)
{
    Assert.isInstanceOf(SmileFactory.class, objectMapper.getFactory(), "SmileFactory required");
    super.setObjectMapper(objectMapper);
}
 AllEncompassingFormHttpMessageConverter
 extends FormHttpMessageConverter
org.springframework.http.converter.support.AllEncompassingFormHttpMessageConverter
public AllEncompassingFormHttpMessageConverter AllEncompassingFormHttpMessageConverter()
{
    try {
        addPartConverter(new SourceHttpMessageConverter<>());
    } catch (Error err) {
    }
    if (jaxb2Present && !jackson2XmlPresent) {
        addPartConverter(new Jaxb2RootElementHttpMessageConverter());
    } 
    if (jackson2Present) {
        addPartConverter(new MappingJackson2HttpMessageConverter());
    } else if (gsonPresent) {
        addPartConverter(new GsonHttpMessageConverter());
    } else if (jsonbPresent) {
        addPartConverter(new JsonbHttpMessageConverter());
    } 
    if (jackson2XmlPresent) {
        addPartConverter(new MappingJackson2XmlHttpMessageConverter());
    } 
    if (jackson2SmilePresent) {
        addPartConverter(new MappingJackson2SmileHttpMessageConverter());
    } 
}
 AbstractJaxb2HttpMessageConverter<T>
 extends AbstractXmlHttpMessageConverter<T>
org.springframework.http.converter.xml.AbstractJaxb2HttpMessageConverter
protected void customizeMarshaller(Marshaller marshaller)
{
}
org.springframework.http.converter.xml.AbstractJaxb2HttpMessageConverter
protected void customizeUnmarshaller(Unmarshaller unmarshaller)
{
}
 AbstractXmlHttpMessageConverter<T>
 extends AbstractHttpMessageConverter<T>
org.springframework.http.converter.xml.AbstractXmlHttpMessageConverter
protected AbstractXmlHttpMessageConverter AbstractXmlHttpMessageConverter()
{
    super(MediaType.APPLICATION_XML, MediaType.TEXT_XML, new MediaType("application", "*+xml"));
}
org.springframework.http.converter.xml.AbstractXmlHttpMessageConverter
protected abstract T readFromSource(Class<?> clazz, HttpHeaders headers, Source source)
org.springframework.http.converter.xml.AbstractXmlHttpMessageConverter
@Override public final T readInternal(Class<?> clazz, HttpInputMessage inputMessage)
{
    try {
        return readFromSource(clazz, inputMessage.getHeaders(), new StreamSource(inputMessage.getBody()));
    } catch (IOException | HttpMessageConversionException ex) {
        throw ex;
    } catch (Exception ex) {
        throw new HttpMessageNotReadableException("Could not unmarshal to [" + clazz + "]: " + ex.getMessage(), ex, inputMessage);
    }
}
org.springframework.http.converter.xml.AbstractXmlHttpMessageConverter
protected void transform(Source source, Result result)
{
    this.transformerFactory.newTransformer().transform(source, result);
}
org.springframework.http.converter.xml.AbstractXmlHttpMessageConverter
@Override protected final void writeInternal(T t, HttpOutputMessage outputMessage)
{
    try {
        writeToResult(t, outputMessage.getHeaders(), new StreamResult(outputMessage.getBody()));
    } catch (IOException | HttpMessageConversionException ex) {
        throw ex;
    } catch (Exception ex) {
        throw new HttpMessageNotWritableException("Could not marshal [" + t + "]: " + ex.getMessage(), ex);
    }
}
org.springframework.http.converter.xml.AbstractXmlHttpMessageConverter
protected abstract void writeToResult(T t, HttpHeaders headers, Result result)
 Jaxb2CollectionHttpMessageConverter<T>
 extends AbstractJaxb2HttpMessageConverter<T> implements GenericHttpMessageConverter<T>
org.springframework.http.converter.xml.Jaxb2CollectionHttpMessageConverter
@Override public boolean canRead(Class<?> clazz, @Nullable MediaType mediaType)
{
    return false;
}
org.springframework.http.converter.xml.Jaxb2CollectionHttpMessageConverter
@Override public boolean canRead(Type type, @Nullable Class<?> contextClass, @Nullable MediaType mediaType)
{
    if (!(type instanceof ParameterizedType)) {
        return false;
    } 
    ParameterizedType parameterizedType = (ParameterizedType)type;
    if (!(parameterizedType.getRawType() instanceof Class)) {
        return false;
    } 
    Class<?> rawType = (Class<?>)parameterizedType.getRawType();
    if (!(Collection.class.isAssignableFrom(rawType))) {
        return false;
    } 
    if (parameterizedType.getActualTypeArguments().length != 1) {
        return false;
    } 
    Type typeArgument = parameterizedType.getActualTypeArguments()[0];
    if (!(typeArgument instanceof Class)) {
        return false;
    } 
    Class<?> typeArgumentClass = (Class<?>)typeArgument;
    return (typeArgumentClass.isAnnotationPresent(XmlRootElement.class) || typeArgumentClass.isAnnotationPresent(XmlType.class)) && canRead(mediaType);
}
org.springframework.http.converter.xml.Jaxb2CollectionHttpMessageConverter
@Override public boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType)
{
    return false;
}
org.springframework.http.converter.xml.Jaxb2CollectionHttpMessageConverter
@Override public boolean canWrite(@Nullable Type type, @Nullable Class<?> clazz, @Nullable MediaType mediaType)
{
    return false;
}
org.springframework.http.converter.xml.Jaxb2CollectionHttpMessageConverter
@SuppressWarnings("unchecked") protected T createCollection(Class<?> collectionClass)
{
    if (!collectionClass.isInterface()) {
        try {
            return (T)ReflectionUtils.accessibleConstructor(collectionClass).newInstance();
        } catch (Throwable ex) {
            throw new IllegalArgumentException("Could not instantiate collection class: " + collectionClass.getName(), ex);
        }
    } else if (List.class == collectionClass) {
        return (T)new ArrayList();
    } else if (SortedSet.class == collectionClass) {
        return (T)new TreeSet();
    } else {
        return (T)new LinkedHashSet();
    }
}
org.springframework.http.converter.xml.Jaxb2CollectionHttpMessageConverter
protected XMLInputFactory createXmlInputFactory()
{
    return StaxUtils.createDefensiveInputFactory();
}
org.springframework.http.converter.xml.Jaxb2CollectionHttpMessageConverter
@Override @SuppressWarnings("unchecked") public T read(Type type, @Nullable Class<?> contextClass, HttpInputMessage inputMessage)
{
    ParameterizedType parameterizedType = (ParameterizedType)type;
    T result = createCollection((Class<?>)parameterizedType.getRawType());
    Class<?> elementClass = (Class<?>)parameterizedType.getActualTypeArguments()[0];
    try {
        Unmarshaller unmarshaller = createUnmarshaller(elementClass);
        XMLStreamReader streamReader = this.inputFactory.createXMLStreamReader(inputMessage.getBody());
        int event = moveToFirstChildOfRootElement(streamReader);
        while (event != XMLStreamReader.END_DOCUMENT) {
            if (elementClass.isAnnotationPresent(XmlRootElement.class)) {
                result.add(unmarshaller.unmarshal(streamReader));
            } else if (elementClass.isAnnotationPresent(XmlType.class)) {
                result.add(unmarshaller.unmarshal(streamReader, elementClass).getValue());
            } else {
                throw new HttpMessageNotReadableException("Cannot unmarshal to [" + elementClass + "]", inputMessage);
            }
            event = moveToNextElement(streamReader);
        }
        return result;
    } catch (XMLStreamException ex) {
        throw new HttpMessageNotReadableException("Failed to read XML stream: " + ex.getMessage(), ex, inputMessage);
    } catch (UnmarshalException ex) {
        throw new HttpMessageNotReadableException("Could not unmarshal to [" + elementClass + "]: " + ex.getMessage(), ex, inputMessage);
    } catch (JAXBException ex) {
        throw new HttpMessageConversionException("Invalid JAXB setup: " + ex.getMessage(), ex);
    }
}
org.springframework.http.converter.xml.Jaxb2CollectionHttpMessageConverter
@Override protected T readFromSource(Class<?> clazz, HttpHeaders headers, Source source)
{
    throw new UnsupportedOperationException();
}
org.springframework.http.converter.xml.Jaxb2CollectionHttpMessageConverter
@Override protected boolean supports(Class<?> clazz)
{
    throw new UnsupportedOperationException();
}
org.springframework.http.converter.xml.Jaxb2CollectionHttpMessageConverter
@Override public void write(T t, @Nullable Type type, @Nullable MediaType contentType, HttpOutputMessage outputMessage)
{
    throw new UnsupportedOperationException();
}
org.springframework.http.converter.xml.Jaxb2CollectionHttpMessageConverter
@Override protected void writeToResult(T t, HttpHeaders headers, Result result)
{
    throw new UnsupportedOperationException();
}
 Jaxb2RootElementHttpMessageConverter
 extends AbstractJaxb2HttpMessageConverter<Object>
org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter
@Override public boolean canRead(Class<?> clazz, @Nullable MediaType mediaType)
{
    return (clazz.isAnnotationPresent(XmlRootElement.class) || clazz.isAnnotationPresent(XmlType.class)) && canRead(mediaType);
}
org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter
@Override public boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType)
{
    return (AnnotationUtils.findAnnotation(clazz, XmlRootElement.class) != null && canWrite(mediaType));
}
org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter
public boolean isProcessExternalEntities()
{
    return this.processExternalEntities;
}
org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter
public boolean isSupportDtd()
{
    return this.supportDtd;
}
org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter
public void setProcessExternalEntities(boolean processExternalEntities)
{
    this.processExternalEntities = processExternalEntities;
    if (processExternalEntities) {
        this.supportDtd = true;
    } 
}
org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter
public void setSupportDtd(boolean supportDtd)
{
    this.supportDtd = supportDtd;
}
org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter
@Override protected boolean supports(Class<?> clazz)
{
    throw new UnsupportedOperationException();
}
org.springframework.http.converter.xml.Jaxb2RootElementHttpMessageConverter
@Override protected void writeToResult(Object o, HttpHeaders headers, Result result)
{
    try {
        Class<?> clazz = ClassUtils.getUserClass(o);
        Marshaller marshaller = createMarshaller(clazz);
        setCharset(headers.getContentType(), marshaller);
        marshaller.marshal(o, result);
    } catch (MarshalException ex) {
        throw ex;
    } catch (JAXBException ex) {
        throw new HttpMessageConversionException("Invalid JAXB setup: " + ex.getMessage(), ex);
    }
}
 MappingJackson2XmlHttpMessageConverter
 extends AbstractJackson2HttpMessageConverter
org.springframework.http.converter.xml.MappingJackson2XmlHttpMessageConverter
public MappingJackson2XmlHttpMessageConverter MappingJackson2XmlHttpMessageConverter()
{
    this(Jackson2ObjectMapperBuilder.xml().build());
}
org.springframework.http.converter.xml.MappingJackson2XmlHttpMessageConverter
public MappingJackson2XmlHttpMessageConverter MappingJackson2XmlHttpMessageConverter(ObjectMapper objectMapper)
{
    super(objectMapper, new MediaType("application", "xml", StandardCharsets.UTF_8), new MediaType("text", "xml", StandardCharsets.UTF_8), new MediaType("application", "*+xml", StandardCharsets.UTF_8));
    Assert.isInstanceOf(XmlMapper.class, objectMapper, "XmlMapper required");
}
org.springframework.http.converter.xml.MappingJackson2XmlHttpMessageConverter
@Override public void setObjectMapper(ObjectMapper objectMapper)
{
    Assert.isInstanceOf(XmlMapper.class, objectMapper, "XmlMapper required");
    super.setObjectMapper(objectMapper);
}
 MarshallingHttpMessageConverter
 extends AbstractXmlHttpMessageConverter<Object>
org.springframework.http.converter.xml.MarshallingHttpMessageConverter
public MarshallingHttpMessageConverter MarshallingHttpMessageConverter()
{
}
org.springframework.http.converter.xml.MarshallingHttpMessageConverter
public MarshallingHttpMessageConverter MarshallingHttpMessageConverter(Marshaller marshaller)
{
    Assert.notNull(marshaller, "Marshaller must not be null");
    this.marshaller = marshaller;
    if (marshaller instanceof Unmarshaller) {
        this.unmarshaller = (Unmarshaller)marshaller;
    } 
}
org.springframework.http.converter.xml.MarshallingHttpMessageConverter
public MarshallingHttpMessageConverter MarshallingHttpMessageConverter(Marshaller marshaller, Unmarshaller unmarshaller)
{
    Assert.notNull(marshaller, "Marshaller must not be null");
    Assert.notNull(unmarshaller, "Unmarshaller must not be null");
    this.marshaller = marshaller;
    this.unmarshaller = unmarshaller;
}
org.springframework.http.converter.xml.MarshallingHttpMessageConverter
@Override public boolean canRead(Class<?> clazz, @Nullable MediaType mediaType)
{
    return (canRead(mediaType) && this.unmarshaller != null && this.unmarshaller.supports(clazz));
}
org.springframework.http.converter.xml.MarshallingHttpMessageConverter
@Override public boolean canWrite(Class<?> clazz, @Nullable MediaType mediaType)
{
    return (canWrite(mediaType) && this.marshaller != null && this.marshaller.supports(clazz));
}
org.springframework.http.converter.xml.MarshallingHttpMessageConverter
@Override protected Object readFromSource(Class<?> clazz, HttpHeaders headers, Source source)
{
    Assert.notNull(this.unmarshaller, "Property 'unmarshaller' is required");
    Object result = this.unmarshaller.unmarshal(source);
    if (!clazz.isInstance(result)) {
        throw new TypeMismatchException(result, clazz);
    } 
    return result;
}
org.springframework.http.converter.xml.MarshallingHttpMessageConverter
public void setMarshaller(Marshaller marshaller)
{
    this.marshaller = marshaller;
}
org.springframework.http.converter.xml.MarshallingHttpMessageConverter
public void setUnmarshaller(Unmarshaller unmarshaller)
{
    this.unmarshaller = unmarshaller;
}
org.springframework.http.converter.xml.MarshallingHttpMessageConverter
@Override protected boolean supports(Class<?> clazz)
{
    throw new UnsupportedOperationException();
}
org.springframework.http.converter.xml.MarshallingHttpMessageConverter
@Override protected void writeToResult(Object o, HttpHeaders headers, Result result)
{
    Assert.notNull(this.marshaller, "Property 'marshaller' is required");
    this.marshaller.marshal(o, result);
}
 SourceHttpMessageConverter<T>
 extends AbstractHttpMessageConverter<T>
org.springframework.http.converter.xml.SourceHttpMessageConverter
public SourceHttpMessageConverter SourceHttpMessageConverter()
{
    super(MediaType.APPLICATION_XML, MediaType.TEXT_XML, new MediaType("application", "*+xml"));
}
org.springframework.http.converter.xml.SourceHttpMessageConverter
@Override @Nullable protected Long getContentLength(T t, @Nullable MediaType contentType)
{
    if (t instanceof DOMSource) {
        try {
            CountingOutputStream os = new CountingOutputStream();
            transform(t, new StreamResult(os));
            return os.count;
        } catch (TransformerException ex) {
        }
    } 
    return null;
}
org.springframework.http.converter.xml.SourceHttpMessageConverter
public boolean isProcessExternalEntities()
{
    return this.processExternalEntities;
}
org.springframework.http.converter.xml.SourceHttpMessageConverter
public boolean isSupportDtd()
{
    return this.supportDtd;
}
org.springframework.http.converter.xml.SourceHttpMessageConverter
@Override @SuppressWarnings("unchecked") protected T readInternal(Class<?> clazz, HttpInputMessage inputMessage)
{
    InputStream body = inputMessage.getBody();
    if (DOMSource.class == clazz) {
        return (T)readDOMSource(body, inputMessage);
    } else if (SAXSource.class == clazz) {
        return (T)readSAXSource(body, inputMessage);
    } else if (StAXSource.class == clazz) {
        return (T)readStAXSource(body, inputMessage);
    } else if (StreamSource.class == clazz || Source.class == clazz) {
        return (T)readStreamSource(body);
    } else {
        throw new HttpMessageNotReadableException("Could not read class [" + clazz + "]. Only DOMSource, SAXSource, StAXSource, and StreamSource are supported.", inputMessage);
    }
}
org.springframework.http.converter.xml.SourceHttpMessageConverter
public void setProcessExternalEntities(boolean processExternalEntities)
{
    this.processExternalEntities = processExternalEntities;
    if (processExternalEntities) {
        this.supportDtd = true;
    } 
}
org.springframework.http.converter.xml.SourceHttpMessageConverter
public void setSupportDtd(boolean supportDtd)
{
    this.supportDtd = supportDtd;
}
org.springframework.http.converter.xml.SourceHttpMessageConverter
@Override public boolean supports(Class<?> clazz)
{
    return SUPPORTED_CLASSES.contains(clazz);
}
org.springframework.http.converter.xml.SourceHttpMessageConverter
@Override protected void writeInternal(T t, HttpOutputMessage outputMessage)
{
    try {
        Result result = new StreamResult(outputMessage.getBody());
        transform(t, result);
    } catch (TransformerException ex) {
        throw new HttpMessageNotWritableException("Could not transform [" + t + "] to output message", ex);
    }
}
 DefaultPathContainer
 implements PathContainer
org.springframework.http.server.DefaultPathContainer
@Override public List<Element> elements()
{
    return this.elements;
}
org.springframework.http.server.DefaultPathContainer
@Override public boolean equals(@Nullable Object other)
{
    if (this == other) {
        return true;
    } 
    if (!(other instanceof PathContainer)) {
        return false;
    } 
    return value().equals(((PathContainer)other).value());
}
org.springframework.http.server.DefaultPathContainer
@Override public int hashCode()
{
    return this.path.hashCode();
}
org.springframework.http.server.DefaultPathContainer
@Override public String toString()
{
    return value();
}
org.springframework.http.server.DefaultPathContainer
@Override public String value()
{
    return this.path;
}
 DefaultRequestPath
 implements RequestPath
org.springframework.http.server.DefaultRequestPath
@Override public PathContainer contextPath()
{
    return this.contextPath;
}
org.springframework.http.server.DefaultRequestPath
@Override public List<Element> elements()
{
    return this.fullPath.elements();
}
org.springframework.http.server.DefaultRequestPath
@Override public boolean equals(@Nullable Object other)
{
    if (this == other) {
        return true;
    } 
    if (other == null || getClass() != other.getClass()) {
        return false;
    } 
    DefaultRequestPath otherPath = (DefaultRequestPath)other;
    return (this.fullPath.equals(otherPath.fullPath) && this.contextPath.equals(otherPath.contextPath) && this.pathWithinApplication.equals(otherPath.pathWithinApplication));
}
org.springframework.http.server.DefaultRequestPath
@Override public RequestPath modifyContextPath(String contextPath)
{
    return new DefaultRequestPath(this, contextPath);
}
org.springframework.http.server.DefaultRequestPath
@Override public PathContainer pathWithinApplication()
{
    return this.pathWithinApplication;
}
org.springframework.http.server.DefaultRequestPath
@Override public String toString()
{
    return this.fullPath.toString();
}
org.springframework.http.server.DefaultRequestPath
@Override public String value()
{
    return this.fullPath.value();
}
 PathContainer
 RequestPath
inherit classes
  • PathContainer
 ServerHttpAsyncRequestControl
 ServerHttpRequest
inherit classes
  • HttpRequest
  • HttpInputMessage
 ServerHttpResponse
inherit classes
  • HttpOutputMessage
  • Flushable
  • Closeable
 ServletServerHttpAsyncRequestControl
 implements ServerHttpAsyncRequestControl, AsyncListener
org.springframework.http.server.ServletServerHttpAsyncRequestControl
@Override public void complete()
{
    if (this.asyncContext != null && isStarted() && !isCompleted()) {
        this.asyncContext.complete();
    } 
}
org.springframework.http.server.ServletServerHttpAsyncRequestControl
@Override public boolean isCompleted()
{
    return this.asyncCompleted.get();
}
org.springframework.http.server.ServletServerHttpAsyncRequestControl
@Override public boolean isStarted()
{
    return (this.asyncContext != null && this.request.getServletRequest().isAsyncStarted());
}
org.springframework.http.server.ServletServerHttpAsyncRequestControl
@Override public void onComplete(AsyncEvent event)
{
    this.asyncContext = null;
    this.asyncCompleted.set(true);
}
org.springframework.http.server.ServletServerHttpAsyncRequestControl
@Override public void onError(AsyncEvent event)
{
}
org.springframework.http.server.ServletServerHttpAsyncRequestControl
@Override public void onStartAsync(AsyncEvent event)
{
}
org.springframework.http.server.ServletServerHttpAsyncRequestControl
@Override public void onTimeout(AsyncEvent event)
{
}
org.springframework.http.server.ServletServerHttpAsyncRequestControl
@Override public void start()
{
    start(NO_TIMEOUT_VALUE);
}
org.springframework.http.server.ServletServerHttpAsyncRequestControl
@Override public void start(long timeout)
{
    Assert.state(!isCompleted(), "Async processing has already completed");
    if (isStarted()) {
        return ;
    } 
    HttpServletRequest servletRequest = this.request.getServletRequest();
    HttpServletResponse servletResponse = this.response.getServletResponse();
    this.asyncContext = servletRequest.startAsync(servletRequest, servletResponse);
    this.asyncContext.addListener(this);
    if (timeout != NO_TIMEOUT_VALUE) {
        this.asyncContext.setTimeout(timeout);
    } 
}
 ServletServerHttpRequest
 implements ServerHttpRequest
org.springframework.http.server.ServletServerHttpRequest
protected static final Charset FORM_CHARSET
org.springframework.http.server.ServletServerHttpRequest
protected static final String FORM_CONTENT_TYPE
org.springframework.http.server.ServletServerHttpRequest
public ServletServerHttpRequest ServletServerHttpRequest(HttpServletRequest servletRequest)
{
    Assert.notNull(servletRequest, "HttpServletRequest must not be null");
    this.servletRequest = servletRequest;
}
org.springframework.http.server.ServletServerHttpRequest
@Override public ServerHttpAsyncRequestControl getAsyncRequestControl(ServerHttpResponse response)
{
    if (this.asyncRequestControl == null) {
        if (!ServletServerHttpResponse.class.isInstance(response)) {
            throw new IllegalArgumentException("Response must be a ServletServerHttpResponse: " + response.getClass());
        } 
        ServletServerHttpResponse servletServerResponse = (ServletServerHttpResponse)response;
        this.asyncRequestControl = new ServletServerHttpAsyncRequestControl(this, servletServerResponse);
    } 
    return this.asyncRequestControl;
}
org.springframework.http.server.ServletServerHttpRequest
@Override public HttpHeaders getHeaders()
{
    if (this.headers == null) {
        this.headers = new HttpHeaders();
        for (Enumeration<?> names = this.servletRequest.getHeaderNames(); names.hasMoreElements(); ) {
            String headerName = (String)names.nextElement();
            for (Enumeration<?> headerValues = this.servletRequest.getHeaders(headerName); headerValues.hasMoreElements(); ) {
                String headerValue = (String)headerValues.nextElement();
                this.headers.add(headerName, headerValue);
            }
        }
        try {
            MediaType contentType = this.headers.getContentType();
            if (contentType == null) {
                String requestContentType = this.servletRequest.getContentType();
                if (StringUtils.hasLength(requestContentType)) {
                    contentType = MediaType.parseMediaType(requestContentType);
                    this.headers.setContentType(contentType);
                } 
            } 
            if (contentType != null && contentType.getCharset() == null) {
                String requestEncoding = this.servletRequest.getCharacterEncoding();
                if (StringUtils.hasLength(requestEncoding)) {
                    Charset charSet = Charset.forName(requestEncoding);
                    Map<String, String> params = new LinkedCaseInsensitiveMap<>();
                    params.putAll(contentType.getParameters());
                    params.put("charset", charSet.toString());
                    MediaType mediaType = new MediaType(contentType.getType(), contentType.getSubtype(), params);
                    this.headers.setContentType(mediaType);
                } 
            } 
        } catch (InvalidMediaTypeException ex) {
        }
        if (this.headers.getContentLength() < 0) {
            int requestContentLength = this.servletRequest.getContentLength();
            if (requestContentLength != -1) {
                this.headers.setContentLength(requestContentLength);
            } 
        } 
    } 
    return this.headers;
}
org.springframework.http.server.ServletServerHttpRequest
@Override public InetSocketAddress getLocalAddress()
{
    return new InetSocketAddress(this.servletRequest.getLocalName(), this.servletRequest.getLocalPort());
}
org.springframework.http.server.ServletServerHttpRequest
@Override @Nullable public HttpMethod getMethod()
{
    return HttpMethod.resolve(this.servletRequest.getMethod());
}
org.springframework.http.server.ServletServerHttpRequest
@Override public String getMethodValue()
{
    return this.servletRequest.getMethod();
}
org.springframework.http.server.ServletServerHttpRequest
@Override public Principal getPrincipal()
{
    return this.servletRequest.getUserPrincipal();
}
org.springframework.http.server.ServletServerHttpRequest
@Override public InetSocketAddress getRemoteAddress()
{
    return new InetSocketAddress(this.servletRequest.getRemoteHost(), this.servletRequest.getRemotePort());
}
org.springframework.http.server.ServletServerHttpRequest
public HttpServletRequest getServletRequest()
{
    return this.servletRequest;
}
 ServletServerHttpResponse
 implements ServerHttpResponse
org.springframework.http.server.ServletServerHttpResponse
public ServletServerHttpResponse ServletServerHttpResponse(HttpServletResponse servletResponse)
{
    Assert.notNull(servletResponse, "HttpServletResponse must not be null");
    this.servletResponse = servletResponse;
    this.headers = new ServletResponseHttpHeaders();
}
org.springframework.http.server.ServletServerHttpResponse
@Override public void close()
{
    writeHeaders();
}
org.springframework.http.server.ServletServerHttpResponse
@Override public void flush()
{
    writeHeaders();
    if (this.bodyUsed) {
        this.servletResponse.flushBuffer();
    } 
}
org.springframework.http.server.ServletServerHttpResponse
@Override public OutputStream getBody()
{
    this.bodyUsed = true;
    writeHeaders();
    return this.servletResponse.getOutputStream();
}
org.springframework.http.server.ServletServerHttpResponse
@Override public HttpHeaders getHeaders()
{
    return (this.headersWritten ? HttpHeaders.readOnlyHttpHeaders(this.headers) : this.headers);
}
org.springframework.http.server.ServletServerHttpResponse
public HttpServletResponse getServletResponse()
{
    return this.servletResponse;
}
org.springframework.http.server.ServletServerHttpResponse
@Override public void setStatusCode(HttpStatus status)
{
    Assert.notNull(status, "HttpStatus must not be null");
    this.servletResponse.setStatus(status.value());
}
 AbstractListenerReadPublisher<T>
 implements Publisher<T>
org.springframework.http.server.reactive.AbstractListenerReadPublisher
public AbstractListenerReadPublisher AbstractListenerReadPublisher()
{
    this("");
}
org.springframework.http.server.reactive.AbstractListenerReadPublisher
public AbstractListenerReadPublisher AbstractListenerReadPublisher(String logPrefix)
{
    this.logPrefix = logPrefix;
}
org.springframework.http.server.reactive.AbstractListenerReadPublisher
protected abstract void checkOnDataAvailable()
org.springframework.http.server.reactive.AbstractListenerReadPublisher
volatile boolean completionBeforeDemand
org.springframework.http.server.reactive.AbstractListenerReadPublisher
volatile long demand
org.springframework.http.server.reactive.AbstractListenerReadPublisher
protected abstract void discardData()
org.springframework.http.server.reactive.AbstractListenerReadPublisher
@Nullable volatile Throwable errorBeforeDemand
org.springframework.http.server.reactive.AbstractListenerReadPublisher
public String getLogPrefix()
{
    return this.logPrefix;
}
org.springframework.http.server.reactive.AbstractListenerReadPublisher
public void onAllDataRead()
{
    rsReadLogger.trace(getLogPrefix() + "onAllDataRead");
    this.state.get().onAllDataRead(this);
}
org.springframework.http.server.reactive.AbstractListenerReadPublisher
public final void onDataAvailable()
{
    rsReadLogger.trace(getLogPrefix() + "onDataAvailable");
    this.state.get().onDataAvailable(this);
}
org.springframework.http.server.reactive.AbstractListenerReadPublisher
public final void onError(Throwable ex)
{
    if (rsReadLogger.isTraceEnabled()) {
        rsReadLogger.trace(getLogPrefix() + "Connection error: " + ex);
    } 
    this.state.get().onError(this, ex);
}
org.springframework.http.server.reactive.AbstractListenerReadPublisher
@Nullable protected abstract T read()
org.springframework.http.server.reactive.AbstractListenerReadPublisher
protected abstract void readingPaused()
org.springframework.http.server.reactive.AbstractListenerReadPublisher
protected static Log rsReadLogger
org.springframework.http.server.reactive.AbstractListenerReadPublisher
@Override public void subscribe(Subscriber<?> subscriber)
{
    this.state.get().subscribe(this, subscriber);
}
org.springframework.http.server.reactive.AbstractListenerReadPublisher
@Nullable volatile Subscriber<?> subscriber
 AbstractListenerServerHttpResponse
 extends AbstractServerHttpResponse
org.springframework.http.server.reactive.AbstractListenerServerHttpResponse
public AbstractListenerServerHttpResponse AbstractListenerServerHttpResponse(DataBufferFactory dataBufferFactory)
{
    super(dataBufferFactory);
}
org.springframework.http.server.reactive.AbstractListenerServerHttpResponse
public AbstractListenerServerHttpResponse AbstractListenerServerHttpResponse(DataBufferFactory dataBufferFactory, HttpHeaders headers)
{
    super(dataBufferFactory, headers);
}
org.springframework.http.server.reactive.AbstractListenerServerHttpResponse
protected abstract Processor<?, Void> createBodyFlushProcessor()
org.springframework.http.server.reactive.AbstractListenerServerHttpResponse
@Override protected final Mono<Void> writeAndFlushWithInternal(Publisher<?> body)
{
    if (this.writeCalled.compareAndSet(false, true)) {
        Processor<? super Publisher<? extends DataBuffer>, Void> processor = createBodyFlushProcessor();
        return Mono.from(subscriber -> {
            body.subscribe(processor);
            processor.subscribe(subscriber);
        });
    } 
    return Mono.error(new IllegalStateException("writeWith() or writeAndFlushWith() has already been called"));
}
org.springframework.http.server.reactive.AbstractListenerServerHttpResponse
@Override protected final Mono<Void> writeWithInternal(Publisher<?> body)
{
    return writeAndFlushWithInternal(Mono.just(body));
}
 AbstractListenerWriteFlushProcessor<T>
 implements Processor<Publisher<?>, Void>
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor
public AbstractListenerWriteFlushProcessor AbstractListenerWriteFlushProcessor()
{
    this("");
}
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor
public AbstractListenerWriteFlushProcessor AbstractListenerWriteFlushProcessor(String logPrefix)
{
    this.logPrefix = logPrefix;
    this.resultPublisher = new WriteResultPublisher(logPrefix);
}
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor
protected void cancel()
{
    if (rsWriteFlushLogger.isTraceEnabled()) {
        rsWriteFlushLogger.trace(getLogPrefix() + "Received request to cancel");
    } 
    if (this.subscription != null) {
        this.subscription.cancel();
    } 
}
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor
protected abstract Processor<?, Void> createWriteProcessor()
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor
protected abstract void flush()
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor
protected void flushingFailed(Throwable t)
{
}
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor
public String getLogPrefix()
{
    return this.logPrefix;
}
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor
protected abstract boolean isFlushPending()
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor
protected abstract boolean isWritePossible()
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor
@Override public final void onComplete()
{
    if (rsWriteFlushLogger.isTraceEnabled()) {
        rsWriteFlushLogger.trace(getLogPrefix() + "Received onComplete");
    } 
    this.state.get().onComplete(this);
}
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor
@Override public final void onError(Throwable ex)
{
    if (rsWriteFlushLogger.isTraceEnabled()) {
        rsWriteFlushLogger.trace(getLogPrefix() + "Received onError: " + ex);
    } 
    this.state.get().onError(this, ex);
}
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor
protected final void onFlushPossible()
{
    this.state.get().onFlushPossible(this);
}
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor
@Override public final void onNext(Publisher<?> publisher)
{
    if (rsWriteFlushLogger.isTraceEnabled()) {
        rsWriteFlushLogger.trace(getLogPrefix() + "Received onNext publisher");
    } 
    this.state.get().onNext(this, publisher);
}
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor
@Override public final void onSubscribe(Subscription subscription)
{
    this.state.get().onSubscribe(this, subscription);
}
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor
protected static final Log rsWriteFlushLogger
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor
@Override public final void subscribe(Subscriber<?> subscriber)
{
    this.resultPublisher.subscribe(subscriber);
}
org.springframework.http.server.reactive.AbstractListenerWriteFlushProcessor
volatile boolean subscriberCompleted
 AbstractListenerWriteProcessor<T>
 implements Processor<T, Void>
org.springframework.http.server.reactive.AbstractListenerWriteProcessor
public AbstractListenerWriteProcessor AbstractListenerWriteProcessor()
{
    this("");
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor
public AbstractListenerWriteProcessor AbstractListenerWriteProcessor(String logPrefix)
{
    this.logPrefix = logPrefix;
    this.resultPublisher = new WriteResultPublisher(logPrefix);
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor
public void cancel()
{
    rsWriteLogger.trace(getLogPrefix() + "Cancellation");
    if (this.subscription != null) {
        this.subscription.cancel();
    } 
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor
@Nullable volatile T currentData
org.springframework.http.server.reactive.AbstractListenerWriteProcessor
protected void dataReceived(T data)
{
    T prev = this.currentData;
    if (prev != null) {
        discardData(data);
        cancel();
        onError(new IllegalStateException("Received new data while current not processed yet."));
    } 
    this.currentData = data;
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor
protected abstract void discardData(T data)
org.springframework.http.server.reactive.AbstractListenerWriteProcessor
public String getLogPrefix()
{
    return this.logPrefix;
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor
protected abstract boolean isDataEmpty(T data)
org.springframework.http.server.reactive.AbstractListenerWriteProcessor
protected abstract boolean isWritePossible()
org.springframework.http.server.reactive.AbstractListenerWriteProcessor
@Override public final void onComplete()
{
    if (rsWriteLogger.isTraceEnabled()) {
        rsWriteLogger.trace(getLogPrefix() + "No more items to write");
    } 
    this.state.get().onComplete(this);
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor
@Override public final void onError(Throwable ex)
{
    if (rsWriteLogger.isTraceEnabled()) {
        rsWriteLogger.trace(getLogPrefix() + "Write source error: " + ex);
    } 
    this.state.get().onError(this, ex);
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor
@Override public final void onNext(T data)
{
    if (rsWriteLogger.isTraceEnabled()) {
        rsWriteLogger.trace(getLogPrefix() + "Item to write");
    } 
    this.state.get().onNext(this, data);
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor
@Override public final void onSubscribe(Subscription subscription)
{
    this.state.get().onSubscribe(this, subscription);
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor
public final void onWritePossible()
{
    if (rsWriteLogger.isTraceEnabled()) {
        rsWriteLogger.trace(getLogPrefix() + "onWritePossible");
    } 
    this.state.get().onWritePossible(this);
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor
protected static final Log rsWriteLogger
org.springframework.http.server.reactive.AbstractListenerWriteProcessor
@Override public final void subscribe(Subscriber<?> subscriber)
{
    this.resultPublisher.subscribe(subscriber);
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor
volatile boolean subscriberCompleted
org.springframework.http.server.reactive.AbstractListenerWriteProcessor
protected abstract boolean write(T data)
org.springframework.http.server.reactive.AbstractListenerWriteProcessor
protected void writingComplete()
{
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor
protected void writingFailed(Throwable ex)
{
}
org.springframework.http.server.reactive.AbstractListenerWriteProcessor
@Deprecated protected void writingPaused()
{
}
 AbstractServerHttpRequest
 implements ServerHttpRequest
org.springframework.http.server.reactive.AbstractServerHttpRequest
public AbstractServerHttpRequest AbstractServerHttpRequest(URI uri, @Nullable String contextPath, HttpHeaders headers)
{
    this.uri = uri;
    this.path = RequestPath.parse(uri, contextPath);
    this.headers = HttpHeaders.readOnlyHttpHeaders(headers);
}
org.springframework.http.server.reactive.AbstractServerHttpRequest
@Override public MultiValueMap<String, HttpCookie> getCookies()
{
    if (this.cookies == null) {
        this.cookies = CollectionUtils.unmodifiableMultiValueMap(initCookies());
    } 
    return this.cookies;
}
org.springframework.http.server.reactive.AbstractServerHttpRequest
@Override public HttpHeaders getHeaders()
{
    return this.headers;
}
org.springframework.http.server.reactive.AbstractServerHttpRequest
@Override public String getId()
{
    if (this.id == null) {
        this.id = initId();
        if (this.id == null) {
            this.id = ObjectUtils.getIdentityHexString(this);
        } 
    } 
    return this.id;
}
org.springframework.http.server.reactive.AbstractServerHttpRequest
<T>public abstract T getNativeRequest()
org.springframework.http.server.reactive.AbstractServerHttpRequest
@Override public RequestPath getPath()
{
    return this.path;
}
org.springframework.http.server.reactive.AbstractServerHttpRequest
@Override public MultiValueMap<String, String> getQueryParams()
{
    if (this.queryParams == null) {
        this.queryParams = CollectionUtils.unmodifiableMultiValueMap(initQueryParams());
    } 
    return this.queryParams;
}
org.springframework.http.server.reactive.AbstractServerHttpRequest
@Nullable @Override public SslInfo getSslInfo()
{
    if (this.sslInfo == null) {
        this.sslInfo = initSslInfo();
    } 
    return this.sslInfo;
}
org.springframework.http.server.reactive.AbstractServerHttpRequest
@Override public URI getURI()
{
    return this.uri;
}
org.springframework.http.server.reactive.AbstractServerHttpRequest
protected abstract MultiValueMap<String, HttpCookie> initCookies()
org.springframework.http.server.reactive.AbstractServerHttpRequest
@Nullable protected String initId()
{
    return null;
}
org.springframework.http.server.reactive.AbstractServerHttpRequest
@Nullable protected abstract SslInfo initSslInfo()
org.springframework.http.server.reactive.AbstractServerHttpRequest
protected final Log logger
 AbstractServerHttpResponse
 implements ServerHttpResponse
org.springframework.http.server.reactive.AbstractServerHttpResponse
public AbstractServerHttpResponse AbstractServerHttpResponse(DataBufferFactory dataBufferFactory)
{
    this(dataBufferFactory, new HttpHeaders());
}
org.springframework.http.server.reactive.AbstractServerHttpResponse
public AbstractServerHttpResponse AbstractServerHttpResponse(DataBufferFactory dataBufferFactory, HttpHeaders headers)
{
    Assert.notNull(dataBufferFactory, "DataBufferFactory must not be null");
    Assert.notNull(headers, "HttpHeaders must not be null");
    this.dataBufferFactory = dataBufferFactory;
    this.headers = headers;
    this.cookies = new LinkedMultiValueMap<>();
}
org.springframework.http.server.reactive.AbstractServerHttpResponse
protected abstract void applyCookies()
org.springframework.http.server.reactive.AbstractServerHttpResponse
protected abstract void applyHeaders()
org.springframework.http.server.reactive.AbstractServerHttpResponse
protected abstract void applyStatusCode()
org.springframework.http.server.reactive.AbstractServerHttpResponse
@Override public void beforeCommit(Supplier<?> action)
{
    this.commitActions.add(action);
}
org.springframework.http.server.reactive.AbstractServerHttpResponse
@Override public final DataBufferFactory bufferFactory()
{
    return this.dataBufferFactory;
}
org.springframework.http.server.reactive.AbstractServerHttpResponse
protected Mono<Void> doCommit()
{
    return doCommit(null);
}
org.springframework.http.server.reactive.AbstractServerHttpResponse
protected Mono<Void> doCommit(@Nullable Supplier<?> writeAction)
{
    if (!this.state.compareAndSet(State.NEW, State.COMMITTING)) {
        return Mono.empty();
    } 
    this.commitActions.add(() -> Mono.fromRunnable(() -> {
        applyStatusCode();
        applyHeaders();
        applyCookies();
        this.state.set(State.COMMITTED);
    }));
    if (writeAction != null) {
        this.commitActions.add(writeAction);
    } 
    Flux<Void> commit = Flux.empty();
    for (Supplier<? extends Mono<Void>> action: this.commitActions) {
        commit = commit.concatWith(action.get());
    }
    return commit.then();
}
org.springframework.http.server.reactive.AbstractServerHttpResponse
@Override public MultiValueMap<String, ResponseCookie> getCookies()
{
    return (this.state.get() == State.COMMITTED ? CollectionUtils.unmodifiableMultiValueMap(this.cookies) : this.cookies);
}
org.springframework.http.server.reactive.AbstractServerHttpResponse
@Override public HttpHeaders getHeaders()
{
    return (this.state.get() == State.COMMITTED ? HttpHeaders.readOnlyHttpHeaders(this.headers) : this.headers);
}
org.springframework.http.server.reactive.AbstractServerHttpResponse
<T>public abstract T getNativeResponse()
org.springframework.http.server.reactive.AbstractServerHttpResponse
@Override @Nullable public HttpStatus getStatusCode()
{
    return (this.statusCode != null ? HttpStatus.resolve(this.statusCode) : null);
}
org.springframework.http.server.reactive.AbstractServerHttpResponse
@Nullable public Integer getStatusCodeValue()
{
    return this.statusCode;
}
org.springframework.http.server.reactive.AbstractServerHttpResponse
@Override public boolean isCommitted()
{
    return this.state.get() != State.NEW;
}
org.springframework.http.server.reactive.AbstractServerHttpResponse
protected final Log logger
org.springframework.http.server.reactive.AbstractServerHttpResponse
@Override public Mono<Void> setComplete()
{
    return !isCommitted() ? doCommit(null) : Mono.empty();
}
org.springframework.http.server.reactive.AbstractServerHttpResponse
@Override public boolean setStatusCode(@Nullable HttpStatus status)
{
    if (this.state.get() == State.COMMITTED) {
        return false;
    } else {
        this.statusCode = (status != null ? status.value() : null);
        return true;
    }
}
org.springframework.http.server.reactive.AbstractServerHttpResponse
public void setStatusCodeValue(@Nullable Integer statusCode)
{
    this.statusCode = statusCode;
}
org.springframework.http.server.reactive.AbstractServerHttpResponse
@Override public final Mono<Void> writeAndFlushWith(Publisher<?> body)
{
    return new ChannelSendOperator<>(body, inner -> doCommit(() -> writeAndFlushWithInternal(inner))).doOnError(t -> removeContentLength());
}
org.springframework.http.server.reactive.AbstractServerHttpResponse
protected abstract Mono<Void> writeAndFlushWithInternal(Publisher<?> body)
org.springframework.http.server.reactive.AbstractServerHttpResponse
@Override @SuppressWarnings("unchecked") public final Mono<Void> writeWith(Publisher<?> body)
{
    if (body instanceof Mono) {
        return ((Mono<? extends DataBuffer>)body).flatMap(buffer -> doCommit(() -> writeWithInternal(Mono.just(buffer))).doOnDiscard(PooledDataBuffer.class, DataBufferUtils::release));
    } 
    return new ChannelSendOperator<>(body, inner -> doCommit(() -> writeWithInternal(inner))).doOnError(t -> removeContentLength());
}
org.springframework.http.server.reactive.AbstractServerHttpResponse
protected abstract Mono<Void> writeWithInternal(Publisher<?> body)
 ChannelSendOperator<T>
 extends Mono<Void> implements Scannable
org.springframework.http.server.reactive.ChannelSendOperator
public ChannelSendOperator ChannelSendOperator(Publisher<?> source, Function<Publisher<T>, Publisher<Void>> writeFunction)
{
    this.source = Flux.from(source);
    this.writeFunction = writeFunction;
}
org.springframework.http.server.reactive.ChannelSendOperator
@Override @Nullable @SuppressWarnings("rawtypes") public Object scanUnsafe(Attr key)
{
    if (key == Attr.PREFETCH) {
        return Integer.MAX_VALUE;
    } 
    if (key == Attr.PARENT) {
        return this.source;
    } 
    return null;
}
org.springframework.http.server.reactive.ChannelSendOperator
@Override public void subscribe(CoreSubscriber<?> actual)
{
    this.source.subscribe(new WriteBarrier(actual));
}
 DefaultServerHttpRequestBuilder
 implements ServerHttpRequest.Builder
org.springframework.http.server.reactive.DefaultServerHttpRequestBuilder
@Override public ServerHttpRequest.Builder contextPath(String contextPath)
{
    this.contextPath = contextPath;
    return this;
}
org.springframework.http.server.reactive.DefaultServerHttpRequestBuilder
@Override public ServerHttpRequest.Builder header(String headerName, String... headerValues)
{
    this.httpHeaders.put(headerName, Arrays.asList(headerValues));
    return this;
}
org.springframework.http.server.reactive.DefaultServerHttpRequestBuilder
@Override public ServerHttpRequest.Builder headers(Consumer<HttpHeaders> headersConsumer)
{
    Assert.notNull(headersConsumer, "'headersConsumer' must not be null");
    headersConsumer.accept(this.httpHeaders);
    return this;
}
org.springframework.http.server.reactive.DefaultServerHttpRequestBuilder
@Override public ServerHttpRequest.Builder method(HttpMethod httpMethod)
{
    this.httpMethodValue = httpMethod.name();
    return this;
}
org.springframework.http.server.reactive.DefaultServerHttpRequestBuilder
@Override public ServerHttpRequest.Builder path(String path)
{
    Assert.isTrue(path.startsWith("/"), "The path does not have a leading slash.");
    this.uriPath = path;
    return this;
}
org.springframework.http.server.reactive.DefaultServerHttpRequestBuilder
@Override public ServerHttpRequest.Builder sslInfo(SslInfo sslInfo)
{
    this.sslInfo = sslInfo;
    return this;
}
org.springframework.http.server.reactive.DefaultServerHttpRequestBuilder
@Override public ServerHttpRequest.Builder uri(URI uri)
{
    this.uri = uri;
    return this;
}
 DefaultSslInfo
 implements SslInfo
org.springframework.http.server.reactive.DefaultSslInfo
@Override @Nullable public X509Certificate[] getPeerCertificates()
{
    return this.peerCertificates;
}
org.springframework.http.server.reactive.DefaultSslInfo
@Override @Nullable public String getSessionId()
{
    return this.sessionId;
}
 HttpHandler
 HttpHeadResponseDecorator
 extends ServerHttpResponseDecorator
org.springframework.http.server.reactive.HttpHeadResponseDecorator
public HttpHeadResponseDecorator HttpHeadResponseDecorator(ServerHttpResponse delegate)
{
    super(delegate);
}
org.springframework.http.server.reactive.HttpHeadResponseDecorator
@Override public final Mono<Void> writeAndFlushWith(Publisher<?> body)
{
    return setComplete();
}
 JettyHeadersAdapter
 implements MultiValueMap<String, String>
org.springframework.http.server.reactive.JettyHeadersAdapter
@Override public void add(String key, @Nullable String value)
{
    this.headers.add(key, value);
}
org.springframework.http.server.reactive.JettyHeadersAdapter
@Override public void addAll(String key, List<?> values)
{
    values.forEach(value -> add(key, value));
}
org.springframework.http.server.reactive.JettyHeadersAdapter
@Override public void addAll(MultiValueMap<String, String> values)
{
    values.forEach(this::addAll);
}
org.springframework.http.server.reactive.JettyHeadersAdapter
@Override public void clear()
{
    this.headers.clear();
}
org.springframework.http.server.reactive.JettyHeadersAdapter
@Override public boolean containsKey(Object key)
{
    return (key instanceof String && this.headers.containsKey((String)key));
}
org.springframework.http.server.reactive.JettyHeadersAdapter
@Override public boolean containsValue(Object value)
{
    return (value instanceof String && this.headers.stream().anyMatch(field -> field.contains((String)value)));
}
org.springframework.http.server.reactive.JettyHeadersAdapter
@Override public Set<Entry<String, List<String>>> entrySet()
{
    return new AbstractSet<Entry<String, List<String>>>() {
        @Override
        public Iterator<Entry<String, List<String>>> iterator() {
            return new EntryIterator();
        }
        @Override
        public int size() {
            return headers.size();
        }
    };
}
org.springframework.http.server.reactive.JettyHeadersAdapter
@Nullable @Override public List<String> get(Object key)
{
    if (containsKey(key)) {
        return this.headers.getValuesList((String)key);
    } 
    return null;
}
org.springframework.http.server.reactive.JettyHeadersAdapter
@Override public String getFirst(String key)
{
    return this.headers.get(key);
}
org.springframework.http.server.reactive.JettyHeadersAdapter
@Override public boolean isEmpty()
{
    return (this.headers.size() == 0);
}
org.springframework.http.server.reactive.JettyHeadersAdapter
@Override public Set<String> keySet()
{
    return this.headers.getFieldNamesCollection();
}
org.springframework.http.server.reactive.JettyHeadersAdapter
@Nullable @Override public List<String> put(String key, List<String> value)
{
    List<String> oldValues = get(key);
    this.headers.put(key, value);
    return oldValues;
}
org.springframework.http.server.reactive.JettyHeadersAdapter
@Override public void putAll(Map<?, ?> map)
{
    map.forEach(this::put);
}
org.springframework.http.server.reactive.JettyHeadersAdapter
@Nullable @Override public List<String> remove(Object key)
{
    if (key instanceof String) {
        List<String> oldValues = get(key);
        this.headers.remove((String)key);
        return oldValues;
    } 
    return null;
}
org.springframework.http.server.reactive.JettyHeadersAdapter
@Override public void set(String key, @Nullable String value)
{
    this.headers.put(key, value);
}
org.springframework.http.server.reactive.JettyHeadersAdapter
@Override public void setAll(Map<String, String> values)
{
    values.forEach(this::set);
}
org.springframework.http.server.reactive.JettyHeadersAdapter
@Override public int size()
{
    return this.headers.getFieldNamesCollection().size();
}
org.springframework.http.server.reactive.JettyHeadersAdapter
@Override public String toString()
{
    return HttpHeaders.formatHeaders(this);
}
org.springframework.http.server.reactive.JettyHeadersAdapter
@Override public Collection<List<String>> values()
{
    return this.headers.getFieldNamesCollection().stream().map(this.headers::getValuesList).collect(Collectors.toList());
}
 JettyHttpHandlerAdapter
 extends ServletHttpHandlerAdapter
org.springframework.http.server.reactive.JettyHttpHandlerAdapter
public JettyHttpHandlerAdapter JettyHttpHandlerAdapter(HttpHandler httpHandler)
{
    super(httpHandler);
}
org.springframework.http.server.reactive.JettyHttpHandlerAdapter
@Override protected ServletServerHttpRequest createRequest(HttpServletRequest request, AsyncContext context)
{
    Assert.notNull(getServletPath(), "Servlet path is not initialized");
    return new JettyServerHttpRequest(request, context, getServletPath(), getDataBufferFactory(), getBufferSize());
}
org.springframework.http.server.reactive.JettyHttpHandlerAdapter
@Override protected ServletServerHttpResponse createResponse(HttpServletResponse response, AsyncContext context, ServletServerHttpRequest request)
{
    return new JettyServerHttpResponse(response, context, getDataBufferFactory(), getBufferSize(), request);
}
 NettyHeadersAdapter
 implements MultiValueMap<String, String>
org.springframework.http.server.reactive.NettyHeadersAdapter
@Override public void add(String key, @Nullable String value)
{
    this.headers.add(key, value);
}
org.springframework.http.server.reactive.NettyHeadersAdapter
@Override public void addAll(String key, List<?> values)
{
    this.headers.add(key, values);
}
org.springframework.http.server.reactive.NettyHeadersAdapter
@Override public void addAll(MultiValueMap<String, String> values)
{
    values.forEach(this.headers::add);
}
org.springframework.http.server.reactive.NettyHeadersAdapter
@Override public void clear()
{
    this.headers.clear();
}
org.springframework.http.server.reactive.NettyHeadersAdapter
@Override public boolean containsKey(Object key)
{
    return (key instanceof String && this.headers.contains((String)key));
}
org.springframework.http.server.reactive.NettyHeadersAdapter
@Override public boolean containsValue(Object value)
{
    return (value instanceof String && this.headers.entries().stream().anyMatch(entry -> value.equals(entry.getValue())));
}
org.springframework.http.server.reactive.NettyHeadersAdapter
@Override public Set<Entry<String, List<String>>> entrySet()
{
    return new AbstractSet<Entry<String, List<String>>>() {
        @Override
        public Iterator<Entry<String, List<String>>> iterator() {
            return new EntryIterator();
        }
        @Override
        public int size() {
            return headers.size();
        }
    };
}
org.springframework.http.server.reactive.NettyHeadersAdapter
@Override @Nullable public List<String> get(Object key)
{
    if (containsKey(key)) {
        return this.headers.getAll((String)key);
    } 
    return null;
}
org.springframework.http.server.reactive.NettyHeadersAdapter
@Override @Nullable public String getFirst(String key)
{
    return this.headers.get(key);
}
org.springframework.http.server.reactive.NettyHeadersAdapter
@Override public boolean isEmpty()
{
    return this.headers.isEmpty();
}
org.springframework.http.server.reactive.NettyHeadersAdapter
@Override public Set<String> keySet()
{
    return this.headers.names();
}
org.springframework.http.server.reactive.NettyHeadersAdapter
@Nullable @Override public List<String> put(String key, @Nullable List<String> value)
{
    List<String> previousValues = this.headers.getAll(key);
    this.headers.set(key, value);
    return previousValues;
}
org.springframework.http.server.reactive.NettyHeadersAdapter
@Override public void putAll(Map<?, ?> map)
{
    map.forEach(this.headers::add);
}
org.springframework.http.server.reactive.NettyHeadersAdapter
@Nullable @Override public List<String> remove(Object key)
{
    if (key instanceof String) {
        List<String> previousValues = this.headers.getAll((String)key);
        this.headers.remove((String)key);
        return previousValues;
    } 
    return null;
}
org.springframework.http.server.reactive.NettyHeadersAdapter
@Override public void set(String key, @Nullable String value)
{
    this.headers.set(key, value);
}
org.springframework.http.server.reactive.NettyHeadersAdapter
@Override public void setAll(Map<String, String> values)
{
    values.forEach(this.headers::set);
}
org.springframework.http.server.reactive.NettyHeadersAdapter
@Override public int size()
{
    return this.headers.names().size();
}
org.springframework.http.server.reactive.NettyHeadersAdapter
@Override public String toString()
{
    return org.springframework.http.HttpHeaders.formatHeaders(this);
}
org.springframework.http.server.reactive.NettyHeadersAdapter
@Override public Collection<List<String>> values()
{
    return this.headers.names().stream().map(this.headers::getAll).collect(Collectors.toList());
}
 ReactorHttpHandlerAdapter
 implements BiFunction<HttpServerRequest, HttpServerResponse, Mono<Void>>
org.springframework.http.server.reactive.ReactorHttpHandlerAdapter
public ReactorHttpHandlerAdapter ReactorHttpHandlerAdapter(HttpHandler httpHandler)
{
    Assert.notNull(httpHandler, "HttpHandler must not be null");
    this.httpHandler = httpHandler;
}
org.springframework.http.server.reactive.ReactorHttpHandlerAdapter
@Override public Mono<Void> apply(HttpServerRequest reactorRequest, HttpServerResponse reactorResponse)
{
    NettyDataBufferFactory bufferFactory = new NettyDataBufferFactory(reactorResponse.alloc());
    try {
        ReactorServerHttpRequest request = new ReactorServerHttpRequest(reactorRequest, bufferFactory);
        ServerHttpResponse response = new ReactorServerHttpResponse(reactorResponse, bufferFactory);
        if (request.getMethod() == HttpMethod.HEAD) {
            response = new HttpHeadResponseDecorator(response);
        } 
        return this.httpHandler.handle(request, response).doOnError(ex -> logger.trace(request.getLogPrefix() + "Failed to complete: " + ex.getMessage())).doOnSuccess(aVoid -> logger.trace(request.getLogPrefix() + "Handling completed"));
    } catch (URISyntaxException ex) {
        if (logger.isDebugEnabled()) {
            logger.debug("Failed to get request URI: " + ex.getMessage());
        } 
        reactorResponse.status(HttpResponseStatus.BAD_REQUEST);
        return Mono.empty();
    }
}
 ReactorServerHttpRequest
 extends AbstractServerHttpRequest
org.springframework.http.server.reactive.ReactorServerHttpRequest
public ReactorServerHttpRequest ReactorServerHttpRequest(HttpServerRequest request, NettyDataBufferFactory bufferFactory)
{
    super(initUri(request), "", initHeaders(request));
    Assert.notNull(bufferFactory, "DataBufferFactory must not be null");
    this.request = request;
    this.bufferFactory = bufferFactory;
}
org.springframework.http.server.reactive.ReactorServerHttpRequest
@Override public Flux<DataBuffer> getBody()
{
    return this.request.receive().retain().map(this.bufferFactory::wrap);
}
org.springframework.http.server.reactive.ReactorServerHttpRequest
@Override public String getMethodValue()
{
    return this.request.method().name();
}
org.springframework.http.server.reactive.ReactorServerHttpRequest
<T>@SuppressWarnings("unchecked") @Override public T getNativeRequest()
{
    return (T)this.request;
}
org.springframework.http.server.reactive.ReactorServerHttpRequest
@Override public InetSocketAddress getRemoteAddress()
{
    return this.request.remoteAddress();
}
org.springframework.http.server.reactive.ReactorServerHttpRequest
@Override @Nullable protected String initId()
{
    return this.request instanceof Connection ? ((Connection)this.request).channel().id().asShortText() : null;
}
 ReactorServerHttpResponse
 extends AbstractServerHttpResponse implements ZeroCopyHttpOutputMessage
org.springframework.http.server.reactive.ReactorServerHttpResponse
public ReactorServerHttpResponse ReactorServerHttpResponse(HttpServerResponse response, DataBufferFactory bufferFactory)
{
    super(bufferFactory, new HttpHeaders(new NettyHeadersAdapter(response.responseHeaders())));
    Assert.notNull(response, "HttpServerResponse must not be null");
    this.response = response;
}
org.springframework.http.server.reactive.ReactorServerHttpResponse
@Override protected void applyHeaders()
{
}
org.springframework.http.server.reactive.ReactorServerHttpResponse
@Override protected void applyStatusCode()
{
    Integer statusCode = getStatusCodeValue();
    if (statusCode != null) {
        this.response.status(statusCode);
    } 
}
org.springframework.http.server.reactive.ReactorServerHttpResponse
<T>@SuppressWarnings("unchecked") @Override public T getNativeResponse()
{
    return (T)this.response;
}
org.springframework.http.server.reactive.ReactorServerHttpResponse
@Override public HttpStatus getStatusCode()
{
    HttpStatus httpStatus = super.getStatusCode();
    return (httpStatus != null ? httpStatus : HttpStatus.resolve(this.response.status().code()));
}
org.springframework.http.server.reactive.ReactorServerHttpResponse
@Override protected Mono<Void> writeAndFlushWithInternal(Publisher<?> publisher)
{
    return this.response.sendGroups(Flux.from(publisher).map(this::toByteBufs)).then();
}
org.springframework.http.server.reactive.ReactorServerHttpResponse
@Override public Mono<Void> writeWith(Path file, long position, long count)
{
    return doCommit(() -> this.response.sendFile(file, position, count).then());
}
org.springframework.http.server.reactive.ReactorServerHttpResponse
@Override protected Mono<Void> writeWithInternal(Publisher<?> publisher)
{
    return this.response.send(toByteBufs(publisher)).then();
}
 ServerHttpRequest
inherit classes
  • HttpRequest
  • ReactiveHttpInputMessage
 ServerHttpRequestDecorator
 implements ServerHttpRequest
org.springframework.http.server.reactive.ServerHttpRequestDecorator
public ServerHttpRequestDecorator ServerHttpRequestDecorator(ServerHttpRequest delegate)
{
    Assert.notNull(delegate, "Delegate is required");
    this.delegate = delegate;
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator
@Override public Flux<DataBuffer> getBody()
{
    return getDelegate().getBody();
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator
@Override public MultiValueMap<String, HttpCookie> getCookies()
{
    return getDelegate().getCookies();
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator
public ServerHttpRequest getDelegate()
{
    return this.delegate;
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator
@Override public HttpHeaders getHeaders()
{
    return getDelegate().getHeaders();
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator
@Override public String getId()
{
    return getDelegate().getId();
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator
@Override @Nullable public HttpMethod getMethod()
{
    return getDelegate().getMethod();
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator
@Override public String getMethodValue()
{
    return getDelegate().getMethodValue();
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator
@Override public RequestPath getPath()
{
    return getDelegate().getPath();
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator
@Override public MultiValueMap<String, String> getQueryParams()
{
    return getDelegate().getQueryParams();
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator
@Override public InetSocketAddress getRemoteAddress()
{
    return getDelegate().getRemoteAddress();
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator
@Nullable @Override public SslInfo getSslInfo()
{
    return getDelegate().getSslInfo();
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator
@Override public URI getURI()
{
    return getDelegate().getURI();
}
org.springframework.http.server.reactive.ServerHttpRequestDecorator
@Override public String toString()
{
    return getClass().getSimpleName() + " [delegate=" + getDelegate() + "]";
}
 ServerHttpResponse
inherit classes
  • ReactiveHttpOutputMessage
 ServerHttpResponseDecorator
 implements ServerHttpResponse
org.springframework.http.server.reactive.ServerHttpResponseDecorator
public ServerHttpResponseDecorator ServerHttpResponseDecorator(ServerHttpResponse delegate)
{
    Assert.notNull(delegate, "Delegate is required");
    this.delegate = delegate;
}
org.springframework.http.server.reactive.ServerHttpResponseDecorator
@Override public void beforeCommit(Supplier<?> action)
{
    getDelegate().beforeCommit(action);
}
org.springframework.http.server.reactive.ServerHttpResponseDecorator
@Override public DataBufferFactory bufferFactory()
{
    return getDelegate().bufferFactory();
}
org.springframework.http.server.reactive.ServerHttpResponseDecorator
@Override public MultiValueMap<String, ResponseCookie> getCookies()
{
    return getDelegate().getCookies();
}
org.springframework.http.server.reactive.ServerHttpResponseDecorator
public ServerHttpResponse getDelegate()
{
    return this.delegate;
}
org.springframework.http.server.reactive.ServerHttpResponseDecorator
@Override public HttpHeaders getHeaders()
{
    return getDelegate().getHeaders();
}
org.springframework.http.server.reactive.ServerHttpResponseDecorator
@Override public HttpStatus getStatusCode()
{
    return getDelegate().getStatusCode();
}
org.springframework.http.server.reactive.ServerHttpResponseDecorator
@Override public boolean isCommitted()
{
    return getDelegate().isCommitted();
}
org.springframework.http.server.reactive.ServerHttpResponseDecorator
@Override public Mono<Void> setComplete()
{
    return getDelegate().setComplete();
}
org.springframework.http.server.reactive.ServerHttpResponseDecorator
@Override public boolean setStatusCode(@Nullable HttpStatus status)
{
    return getDelegate().setStatusCode(status);
}
org.springframework.http.server.reactive.ServerHttpResponseDecorator
@Override public String toString()
{
    return getClass().getSimpleName() + " [delegate=" + getDelegate() + "]";
}
org.springframework.http.server.reactive.ServerHttpResponseDecorator
@Override public Mono<Void> writeAndFlushWith(Publisher<?> body)
{
    return getDelegate().writeAndFlushWith(body);
}
org.springframework.http.server.reactive.ServerHttpResponseDecorator
@Override public Mono<Void> writeWith(Publisher<?> body)
{
    return getDelegate().writeWith(body);
}
 ServletHttpHandlerAdapter
 implements Servlet
org.springframework.http.server.reactive.ServletHttpHandlerAdapter
public ServletHttpHandlerAdapter ServletHttpHandlerAdapter(HttpHandler httpHandler)
{
    Assert.notNull(httpHandler, "HttpHandler must not be null");
    this.httpHandler = httpHandler;
}
org.springframework.http.server.reactive.ServletHttpHandlerAdapter
protected ServletServerHttpRequest createRequest(HttpServletRequest request, AsyncContext context)
{
    Assert.notNull(this.servletPath, "Servlet path is not initialized");
    return new ServletServerHttpRequest(request, context, this.servletPath, getDataBufferFactory(), getBufferSize());
}
org.springframework.http.server.reactive.ServletHttpHandlerAdapter
protected ServletServerHttpResponse createResponse(HttpServletResponse response, AsyncContext context, ServletServerHttpRequest request)
{
    return new ServletServerHttpResponse(response, context, getDataBufferFactory(), getBufferSize(), request);
}
org.springframework.http.server.reactive.ServletHttpHandlerAdapter
@Override public void destroy()
{
}
org.springframework.http.server.reactive.ServletHttpHandlerAdapter
public int getBufferSize()
{
    return this.bufferSize;
}
org.springframework.http.server.reactive.ServletHttpHandlerAdapter
public DataBufferFactory getDataBufferFactory()
{
    return this.dataBufferFactory;
}
org.springframework.http.server.reactive.ServletHttpHandlerAdapter
@Override @Nullable public ServletConfig getServletConfig()
{
    return null;
}
org.springframework.http.server.reactive.ServletHttpHandlerAdapter
@Override public String getServletInfo()
{
    return "";
}
org.springframework.http.server.reactive.ServletHttpHandlerAdapter
@Nullable public String getServletPath()
{
    return this.servletPath;
}
org.springframework.http.server.reactive.ServletHttpHandlerAdapter
@Override public void init(ServletConfig config)
{
    this.servletPath = getServletPath(config);
}
org.springframework.http.server.reactive.ServletHttpHandlerAdapter
@Override public void service(ServletRequest request, ServletResponse response)
{
    if (DispatcherType.ASYNC.equals(request.getDispatcherType())) {
        Throwable ex = (Throwable)request.getAttribute(WRITE_ERROR_ATTRIBUTE_NAME);
        throw new ServletException("Failed to create response content", ex);
    } 
    AsyncContext asyncContext = request.startAsync();
    asyncContext.setTimeout(-1);
    ServletServerHttpRequest httpRequest;
    try {
        httpRequest = createRequest(((HttpServletRequest)request), asyncContext);
    } catch (URISyntaxException ex) {
        if (logger.isDebugEnabled()) {
            logger.debug("Failed to get request  URL: " + ex.getMessage());
        } 
        ((HttpServletResponse)response).setStatus(400);
        asyncContext.complete();
        return ;
    }
    ServerHttpResponse httpResponse = createResponse(((HttpServletResponse)response), asyncContext, httpRequest);
    if (httpRequest.getMethod() == HttpMethod.HEAD) {
        httpResponse = new HttpHeadResponseDecorator(httpResponse);
    } 
    AtomicBoolean isCompleted = new AtomicBoolean();
    HandlerResultAsyncListener listener = new HandlerResultAsyncListener(isCompleted, httpRequest);
    asyncContext.addListener(listener);
    HandlerResultSubscriber subscriber = new HandlerResultSubscriber(asyncContext, isCompleted, httpRequest);
    this.httpHandler.handle(httpRequest, httpResponse).subscribe(subscriber);
}
org.springframework.http.server.reactive.ServletHttpHandlerAdapter
public void setBufferSize(int bufferSize)
{
    Assert.isTrue(bufferSize > 0, "Buffer size must be larger than zero");
    this.bufferSize = bufferSize;
}
org.springframework.http.server.reactive.ServletHttpHandlerAdapter
public void setDataBufferFactory(DataBufferFactory dataBufferFactory)
{
    Assert.notNull(dataBufferFactory, "DataBufferFactory must not be null");
    this.dataBufferFactory = dataBufferFactory;
}
 ServletServerHttpRequest
 extends AbstractServerHttpRequest
org.springframework.http.server.reactive.ServletServerHttpRequest
public ServletServerHttpRequest ServletServerHttpRequest(HttpServletRequest request, AsyncContext asyncContext, String servletPath, DataBufferFactory bufferFactory, int bufferSize)
{
    this(createDefaultHttpHeaders(request), request, asyncContext, servletPath, bufferFactory, bufferSize);
}
org.springframework.http.server.reactive.ServletServerHttpRequest
@Override public Flux<DataBuffer> getBody()
{
    return Flux.from(this.bodyPublisher);
}
org.springframework.http.server.reactive.ServletServerHttpRequest
@Override public String getMethodValue()
{
    return this.request.getMethod();
}
org.springframework.http.server.reactive.ServletServerHttpRequest
<T>@SuppressWarnings("unchecked") @Override public T getNativeRequest()
{
    return (T)this.request;
}
org.springframework.http.server.reactive.ServletServerHttpRequest
@Override public InetSocketAddress getRemoteAddress()
{
    return new InetSocketAddress(this.request.getRemoteHost(), this.request.getRemotePort());
}
org.springframework.http.server.reactive.ServletServerHttpRequest
@Override @Nullable protected SslInfo initSslInfo()
{
    X509Certificate[] certificates = getX509Certificates();
    return certificates != null ? new DefaultSslInfo(getSslSessionId(), certificates) : null;
}
 ServletServerHttpResponse
 extends AbstractListenerServerHttpResponse
org.springframework.http.server.reactive.ServletServerHttpResponse
public ServletServerHttpResponse ServletServerHttpResponse(HttpServletResponse response, AsyncContext asyncContext, DataBufferFactory bufferFactory, int bufferSize, ServletServerHttpRequest request)
{
    this(new HttpHeaders(), response, asyncContext, bufferFactory, bufferSize, request);
}
org.springframework.http.server.reactive.ServletServerHttpResponse
@Override protected void applyHeaders()
{
    getHeaders().forEach((headerName, headerValues) -> {
        for (String headerValue: headerValues) {
            this.response.addHeader(headerName, headerValue);
        }
    });
    MediaType contentType = null;
    try {
        contentType = getHeaders().getContentType();
    } catch (Exception ex) {
        String rawContentType = getHeaders().getFirst(HttpHeaders.CONTENT_TYPE);
        this.response.setContentType(rawContentType);
    }
    if (this.response.getContentType() == null && contentType != null) {
        this.response.setContentType(contentType.toString());
    } 
    Charset charset = (contentType != null ? contentType.getCharset() : null);
    if (this.response.getCharacterEncoding() == null && charset != null) {
        this.response.setCharacterEncoding(charset.name());
    } 
    long contentLength = getHeaders().getContentLength();
    if (contentLength != -1) {
        this.response.setContentLengthLong(contentLength);
    } 
}
org.springframework.http.server.reactive.ServletServerHttpResponse
@Override protected void applyStatusCode()
{
    Integer statusCode = getStatusCodeValue();
    if (statusCode != null) {
        this.response.setStatus(statusCode);
    } 
}
org.springframework.http.server.reactive.ServletServerHttpResponse
@Nullable volatile ResponseBodyFlushProcessor bodyFlushProcessor
org.springframework.http.server.reactive.ServletServerHttpResponse
@Nullable volatile ResponseBodyProcessor bodyProcessor
org.springframework.http.server.reactive.ServletServerHttpResponse
@Override protected Processor<?, Void> createBodyFlushProcessor()
{
    ResponseBodyFlushProcessor processor = new ResponseBodyFlushProcessor();
    this.bodyFlushProcessor = processor;
    return processor;
}
org.springframework.http.server.reactive.ServletServerHttpResponse
volatile boolean flushOnNext
org.springframework.http.server.reactive.ServletServerHttpResponse
<T>@SuppressWarnings("unchecked") @Override public T getNativeResponse()
{
    return (T)this.response;
}
org.springframework.http.server.reactive.ServletServerHttpResponse
@Override public HttpStatus getStatusCode()
{
    HttpStatus httpStatus = super.getStatusCode();
    return (httpStatus != null ? httpStatus : HttpStatus.resolve(this.response.getStatus()));
}
 SslInfo
 TomcatHeadersAdapter
 implements MultiValueMap<String, String>
org.springframework.http.server.reactive.TomcatHeadersAdapter
@Override public void add(String key, @Nullable String value)
{
    this.headers.addValue(key).setString(value);
}
org.springframework.http.server.reactive.TomcatHeadersAdapter
@Override public void addAll(String key, List<?> values)
{
    values.forEach(value -> add(key, value));
}
org.springframework.http.server.reactive.TomcatHeadersAdapter
@Override public void addAll(MultiValueMap<String, String> values)
{
    values.forEach(this::addAll);
}
org.springframework.http.server.reactive.TomcatHeadersAdapter
@Override public void clear()
{
    this.headers.clear();
}
org.springframework.http.server.reactive.TomcatHeadersAdapter
@Override public boolean containsKey(Object key)
{
    if (key instanceof String) {
        return (this.headers.findHeader((String)key, 0) != -1);
    } 
    return false;
}
org.springframework.http.server.reactive.TomcatHeadersAdapter
@Override public Set<Entry<String, List<String>>> entrySet()
{
    return new AbstractSet<Entry<String, List<String>>>() {
        @Override
        public Iterator<Entry<String, List<String>>> iterator() {
            return new EntryIterator();
        }
        @Override
        public int size() {
            return headers.size();
        }
    };
}
org.springframework.http.server.reactive.TomcatHeadersAdapter
@Override @Nullable public List<String> get(Object key)
{
    if (containsKey(key)) {
        return Collections.list(this.headers.values((String)key));
    } 
    return null;
}
org.springframework.http.server.reactive.TomcatHeadersAdapter
@Override public String getFirst(String key)
{
    return this.headers.getHeader(key);
}
org.springframework.http.server.reactive.TomcatHeadersAdapter
@Override public boolean isEmpty()
{
    return (this.headers.size() == 0);
}
org.springframework.http.server.reactive.TomcatHeadersAdapter
@Override public Set<String> keySet()
{
    Set<String> result = new HashSet<>(8);
    Enumeration<String> names = this.headers.names();
    while (names.hasMoreElements()) {
        result.add(names.nextElement());
    }
    return result;
}
org.springframework.http.server.reactive.TomcatHeadersAdapter
@Override @Nullable public List<String> put(String key, List<String> value)
{
    List<String> previousValues = get(key);
    this.headers.removeHeader(key);
    value.forEach(v -> this.headers.addValue(key).setString(v));
    return previousValues;
}
org.springframework.http.server.reactive.TomcatHeadersAdapter
@Override public void putAll(Map<?, ?> map)
{
    map.forEach(this::put);
}
org.springframework.http.server.reactive.TomcatHeadersAdapter
@Override @Nullable public List<String> remove(Object key)
{
    if (key instanceof String) {
        List<String> previousValues = get(key);
        this.headers.removeHeader((String)key);
        return previousValues;
    } 
    return null;
}
org.springframework.http.server.reactive.TomcatHeadersAdapter
@Override public void set(String key, @Nullable String value)
{
    this.headers.setValue(key).setString(value);
}
org.springframework.http.server.reactive.TomcatHeadersAdapter
@Override public void setAll(Map<String, String> values)
{
    values.forEach(this::set);
}
org.springframework.http.server.reactive.TomcatHeadersAdapter
@Override public int size()
{
    Enumeration<String> names = this.headers.names();
    int size = 0;
    while (names.hasMoreElements()) {
        size++;
        names.nextElement();
    }
    return size;
}
org.springframework.http.server.reactive.TomcatHeadersAdapter
@Override public String toString()
{
    return HttpHeaders.formatHeaders(this);
}
org.springframework.http.server.reactive.TomcatHeadersAdapter
@Override public Collection<List<String>> values()
{
    return keySet().stream().map(this::get).collect(Collectors.toList());
}
 TomcatHttpHandlerAdapter
 extends ServletHttpHandlerAdapter
org.springframework.http.server.reactive.TomcatHttpHandlerAdapter
public TomcatHttpHandlerAdapter TomcatHttpHandlerAdapter(HttpHandler httpHandler)
{
    super(httpHandler);
}
org.springframework.http.server.reactive.TomcatHttpHandlerAdapter
@Override protected ServletServerHttpRequest createRequest(HttpServletRequest request, AsyncContext asyncContext)
{
    Assert.notNull(getServletPath(), "Servlet path is not initialized");
    return new TomcatServerHttpRequest(request, asyncContext, getServletPath(), getDataBufferFactory(), getBufferSize());
}
org.springframework.http.server.reactive.TomcatHttpHandlerAdapter
@Override protected ServletServerHttpResponse createResponse(HttpServletResponse response, AsyncContext asyncContext, ServletServerHttpRequest request)
{
    return new TomcatServerHttpResponse(response, asyncContext, getDataBufferFactory(), getBufferSize(), request);
}
 UndertowHeadersAdapter
 implements MultiValueMap<String, String>
org.springframework.http.server.reactive.UndertowHeadersAdapter
@Override public void add(String key, @Nullable String value)
{
    this.headers.add(HttpString.tryFromString(key), value);
}
org.springframework.http.server.reactive.UndertowHeadersAdapter
@Override @SuppressWarnings("unchecked") public void addAll(String key, List<?> values)
{
    this.headers.addAll(HttpString.tryFromString(key), (List<String>)values);
}
org.springframework.http.server.reactive.UndertowHeadersAdapter
@Override public void addAll(MultiValueMap<String, String> values)
{
    values.forEach((key, list) -> this.headers.addAll(HttpString.tryFromString(key), list));
}
org.springframework.http.server.reactive.UndertowHeadersAdapter
@Override public void clear()
{
    this.headers.clear();
}
org.springframework.http.server.reactive.UndertowHeadersAdapter
@Override public boolean containsKey(Object key)
{
    return (key instanceof String && this.headers.contains((String)key));
}
org.springframework.http.server.reactive.UndertowHeadersAdapter
@Override public boolean containsValue(Object value)
{
    return (value instanceof String && this.headers.getHeaderNames().stream().map(this.headers::get).anyMatch(values -> values.contains(value)));
}
org.springframework.http.server.reactive.UndertowHeadersAdapter
@Override public Set<Entry<String, List<String>>> entrySet()
{
    return new AbstractSet<Entry<String, List<String>>>() {
        @Override
        public Iterator<Entry<String, List<String>>> iterator() {
            return new EntryIterator();
        }
        @Override
        public int size() {
            return headers.size();
        }
    };
}
org.springframework.http.server.reactive.UndertowHeadersAdapter
@Override @Nullable public List<String> get(Object key)
{
    if (key instanceof String) {
        return this.headers.get((String)key);
    } 
    return null;
}
org.springframework.http.server.reactive.UndertowHeadersAdapter
@Override public String getFirst(String key)
{
    return this.headers.getFirst(key);
}
org.springframework.http.server.reactive.UndertowHeadersAdapter
@Override public boolean isEmpty()
{
    return (this.headers.size() == 0);
}
org.springframework.http.server.reactive.UndertowHeadersAdapter
@Override public Set<String> keySet()
{
    return this.headers.getHeaderNames().stream().map(HttpString::toString).collect(Collectors.toSet());
}
org.springframework.http.server.reactive.UndertowHeadersAdapter
@Override @Nullable public List<String> put(String key, List<String> value)
{
    HeaderValues previousValues = this.headers.get(key);
    this.headers.putAll(HttpString.tryFromString(key), value);
    return previousValues;
}
org.springframework.http.server.reactive.UndertowHeadersAdapter
@Override public void putAll(Map<?, ?> map)
{
    map.forEach((key, values) -> this.headers.putAll(HttpString.tryFromString(key), values));
}
org.springframework.http.server.reactive.UndertowHeadersAdapter
@Override @Nullable public List<String> remove(Object key)
{
    if (key instanceof String) {
        this.headers.remove((String)key);
    } 
    return null;
}
org.springframework.http.server.reactive.UndertowHeadersAdapter
@Override public void set(String key, @Nullable String value)
{
    this.headers.put(HttpString.tryFromString(key), value);
}
org.springframework.http.server.reactive.UndertowHeadersAdapter
@Override public void setAll(Map<String, String> values)
{
    values.forEach((key, list) -> this.headers.put(HttpString.tryFromString(key), list));
}
org.springframework.http.server.reactive.UndertowHeadersAdapter
@Override public int size()
{
    return this.headers.size();
}
org.springframework.http.server.reactive.UndertowHeadersAdapter
@Override public String toString()
{
    return org.springframework.http.HttpHeaders.formatHeaders(this);
}
org.springframework.http.server.reactive.UndertowHeadersAdapter
@Override public Collection<List<String>> values()
{
    return this.headers.getHeaderNames().stream().map(this.headers::get).collect(Collectors.toList());
}
 UndertowHttpHandlerAdapter
 implements io.undertow.server.HttpHandler
org.springframework.http.server.reactive.UndertowHttpHandlerAdapter
public UndertowHttpHandlerAdapter UndertowHttpHandlerAdapter(HttpHandler httpHandler)
{
    Assert.notNull(httpHandler, "HttpHandler must not be null");
    this.httpHandler = httpHandler;
}
org.springframework.http.server.reactive.UndertowHttpHandlerAdapter
public DataBufferFactory getDataBufferFactory()
{
    return this.bufferFactory;
}
org.springframework.http.server.reactive.UndertowHttpHandlerAdapter
@Override public void handleRequest(HttpServerExchange exchange)
{
    UndertowServerHttpRequest request = null;
    try {
        request = new UndertowServerHttpRequest(exchange, getDataBufferFactory());
    } catch (URISyntaxException ex) {
        if (logger.isWarnEnabled()) {
            logger.debug("Failed to get request URI: " + ex.getMessage());
        } 
        exchange.setStatusCode(400);
        return ;
    }
    ServerHttpResponse response = new UndertowServerHttpResponse(exchange, getDataBufferFactory(), request);
    if (request.getMethod() == HttpMethod.HEAD) {
        response = new HttpHeadResponseDecorator(response);
    } 
    HandlerResultSubscriber resultSubscriber = new HandlerResultSubscriber(exchange, request);
    this.httpHandler.handle(request, response).subscribe(resultSubscriber);
}
org.springframework.http.server.reactive.UndertowHttpHandlerAdapter
public void setDataBufferFactory(DataBufferFactory bufferFactory)
{
    Assert.notNull(bufferFactory, "DataBufferFactory must not be null");
    this.bufferFactory = bufferFactory;
}
 UndertowServerHttpRequest
 extends AbstractServerHttpRequest
org.springframework.http.server.reactive.UndertowServerHttpRequest
public UndertowServerHttpRequest UndertowServerHttpRequest(HttpServerExchange exchange, DataBufferFactory bufferFactory)
{
    super(initUri(exchange), "", initHeaders(exchange));
    this.exchange = exchange;
    this.body = new RequestBodyPublisher(exchange, bufferFactory);
    this.body.registerListeners(exchange);
}
org.springframework.http.server.reactive.UndertowServerHttpRequest
@Override public Flux<DataBuffer> getBody()
{
    return Flux.from(this.body);
}
org.springframework.http.server.reactive.UndertowServerHttpRequest
@Override public String getMethodValue()
{
    return this.exchange.getRequestMethod().toString();
}
org.springframework.http.server.reactive.UndertowServerHttpRequest
<T>@SuppressWarnings("unchecked") @Override public T getNativeRequest()
{
    return (T)this.exchange;
}
org.springframework.http.server.reactive.UndertowServerHttpRequest
@Override public InetSocketAddress getRemoteAddress()
{
    return this.exchange.getSourceAddress();
}
org.springframework.http.server.reactive.UndertowServerHttpRequest
@Override protected String initId()
{
    return ObjectUtils.getIdentityHexString(this.exchange.getConnection());
}
org.springframework.http.server.reactive.UndertowServerHttpRequest
@Nullable @Override protected SslInfo initSslInfo()
{
    SSLSession session = this.exchange.getConnection().getSslSession();
    if (session != null) {
        return new DefaultSslInfo(session);
    } 
    return null;
}
 UndertowServerHttpResponse
 extends AbstractListenerServerHttpResponse implements ZeroCopyHttpOutputMessage
org.springframework.http.server.reactive.UndertowServerHttpResponse
@Override protected void applyCookies()
{
    for (String name: getCookies().keySet()) {
        for (ResponseCookie httpCookie: getCookies().get(name)) {
            Cookie cookie = new CookieImpl(name, httpCookie.getValue());
            if (!httpCookie.getMaxAge().isNegative()) {
                cookie.setMaxAge((int)httpCookie.getMaxAge().getSeconds());
            } 
            if (httpCookie.getDomain() != null) {
                cookie.setDomain(httpCookie.getDomain());
            } 
            if (httpCookie.getPath() != null) {
                cookie.setPath(httpCookie.getPath());
            } 
            cookie.setSecure(httpCookie.isSecure());
            cookie.setHttpOnly(httpCookie.isHttpOnly());
            cookie.setSameSiteMode(httpCookie.getSameSite());
            this.exchange.getResponseCookies().putIfAbsent(name, cookie);
        }
    }
}
org.springframework.http.server.reactive.UndertowServerHttpResponse
@Override protected void applyHeaders()
{
}
org.springframework.http.server.reactive.UndertowServerHttpResponse
@Override protected void applyStatusCode()
{
    Integer statusCode = getStatusCodeValue();
    if (statusCode != null) {
        this.exchange.setStatusCode(statusCode);
    } 
}
org.springframework.http.server.reactive.UndertowServerHttpResponse
@Override protected Processor<?, Void> createBodyFlushProcessor()
{
    return new ResponseBodyFlushProcessor();
}
org.springframework.http.server.reactive.UndertowServerHttpResponse
<T>@SuppressWarnings("unchecked") @Override public T getNativeResponse()
{
    return (T)this.exchange;
}
org.springframework.http.server.reactive.UndertowServerHttpResponse
@Override public HttpStatus getStatusCode()
{
    HttpStatus httpStatus = super.getStatusCode();
    return (httpStatus != null ? httpStatus : HttpStatus.resolve(this.exchange.getStatusCode()));
}
 WriteResultPublisher
 implements Publisher<Void>
org.springframework.http.server.reactive.WriteResultPublisher
public WriteResultPublisher WriteResultPublisher(String logPrefix)
{
    this.logPrefix = logPrefix;
}
org.springframework.http.server.reactive.WriteResultPublisher
volatile boolean completedBeforeSubscribed
org.springframework.http.server.reactive.WriteResultPublisher
@Nullable volatile Throwable errorBeforeSubscribed
org.springframework.http.server.reactive.WriteResultPublisher
public void publishComplete()
{
    if (rsWriteResultLogger.isTraceEnabled()) {
        rsWriteResultLogger.trace(this.logPrefix + this.state + " publishComplete");
    } 
    this.state.get().publishComplete(this);
}
org.springframework.http.server.reactive.WriteResultPublisher
public void publishError(Throwable t)
{
    if (rsWriteResultLogger.isTraceEnabled()) {
        rsWriteResultLogger.trace(this.logPrefix + this.state + " publishError: " + t);
    } 
    this.state.get().publishError(this, t);
}
org.springframework.http.server.reactive.WriteResultPublisher
@Override public final void subscribe(Subscriber<?> subscriber)
{
    if (rsWriteResultLogger.isTraceEnabled()) {
        rsWriteResultLogger.trace(this.logPrefix + this.state + " subscribe: " + subscriber);
    } 
    this.state.get().subscribe(this, subscriber);
}
org.springframework.http.server.reactive.WriteResultPublisher
@Nullable volatile Subscriber<?> subscriber
 HessianClientInterceptor
 extends UrlBasedRemoteAccessor implements MethodInterceptor
org.springframework.remoting.caucho.HessianClientInterceptor
@Override public void afterPropertiesSet()
{
    super.afterPropertiesSet();
    prepare();
}
org.springframework.remoting.caucho.HessianClientInterceptor
protected Object createHessianProxy(HessianProxyFactory proxyFactory)
{
    Assert.notNull(getServiceInterface(), "'serviceInterface' is required");
    return proxyFactory.create(getServiceInterface(), getServiceUrl(), getBeanClassLoader());
}
org.springframework.remoting.caucho.HessianClientInterceptor
public void prepare()
{
    try {
        this.hessianProxy = createHessianProxy(this.proxyFactory);
    } catch (MalformedURLException ex) {
        throw new RemoteLookupFailureException("Service URL [" + getServiceUrl() + "] is invalid", ex);
    }
}
org.springframework.remoting.caucho.HessianClientInterceptor
public void setAllowNonSerializable(boolean allowNonSerializable)
{
    this.proxyFactory.getSerializerFactory().setAllowNonSerializable(allowNonSerializable);
}
org.springframework.remoting.caucho.HessianClientInterceptor
public void setChunkedPost(boolean chunkedPost)
{
    this.proxyFactory.setChunkedPost(chunkedPost);
}
org.springframework.remoting.caucho.HessianClientInterceptor
public void setConnectTimeout(long timeout)
{
    this.proxyFactory.setConnectTimeout(timeout);
}
org.springframework.remoting.caucho.HessianClientInterceptor
public void setConnectionFactory(HessianConnectionFactory connectionFactory)
{
    this.proxyFactory.setConnectionFactory(connectionFactory);
}
org.springframework.remoting.caucho.HessianClientInterceptor
public void setDebug(boolean debug)
{
    this.proxyFactory.setDebug(debug);
}
org.springframework.remoting.caucho.HessianClientInterceptor
public void setHessian2(boolean hessian2)
{
    this.proxyFactory.setHessian2Request(hessian2);
    this.proxyFactory.setHessian2Reply(hessian2);
}
org.springframework.remoting.caucho.HessianClientInterceptor
public void setHessian2Reply(boolean hessian2)
{
    this.proxyFactory.setHessian2Reply(hessian2);
}
org.springframework.remoting.caucho.HessianClientInterceptor
public void setHessian2Request(boolean hessian2)
{
    this.proxyFactory.setHessian2Request(hessian2);
}
org.springframework.remoting.caucho.HessianClientInterceptor
public void setOverloadEnabled(boolean overloadEnabled)
{
    this.proxyFactory.setOverloadEnabled(overloadEnabled);
}
org.springframework.remoting.caucho.HessianClientInterceptor
public void setPassword(String password)
{
    this.proxyFactory.setPassword(password);
}
org.springframework.remoting.caucho.HessianClientInterceptor
public void setProxyFactory(@Nullable HessianProxyFactory proxyFactory)
{
    this.proxyFactory = (proxyFactory != null ? proxyFactory : new HessianProxyFactory());
}
org.springframework.remoting.caucho.HessianClientInterceptor
public void setReadTimeout(long timeout)
{
    this.proxyFactory.setReadTimeout(timeout);
}
org.springframework.remoting.caucho.HessianClientInterceptor
public void setSendCollectionType(boolean sendCollectionType)
{
    this.proxyFactory.getSerializerFactory().setSendCollectionType(sendCollectionType);
}
org.springframework.remoting.caucho.HessianClientInterceptor
public void setSerializerFactory(SerializerFactory serializerFactory)
{
    this.proxyFactory.setSerializerFactory(serializerFactory);
}
org.springframework.remoting.caucho.HessianClientInterceptor
public void setUsername(String username)
{
    this.proxyFactory.setUser(username);
}
 HessianExporter
 extends RemoteExporter implements InitializingBean
org.springframework.remoting.caucho.HessianExporter
public static final String CONTENT_TYPE_HESSIAN
org.springframework.remoting.caucho.HessianExporter
@Override public void afterPropertiesSet()
{
    prepare();
}
org.springframework.remoting.caucho.HessianExporter
protected void doInvoke(HessianSkeleton skeleton, InputStream inputStream, OutputStream outputStream)
{
    ClassLoader originalClassLoader = overrideThreadContextClassLoader();
    try {
        InputStream isToUse = inputStream;
        OutputStream osToUse = outputStream;
        if (this.debugLogger != null && this.debugLogger.isDebugEnabled()) {
            try (PrintWriter debugWriter = new PrintWriter(new CommonsLogWriter(this.debugLogger))){
                @SuppressWarnings("resource") HessianDebugInputStream dis = new HessianDebugInputStream(inputStream, debugWriter);
                @SuppressWarnings("resource") HessianDebugOutputStream dos = new HessianDebugOutputStream(outputStream, debugWriter);
                dis.startTop2();
                dos.startTop2();
                isToUse = dis;
                osToUse = dos;
            }
        } 
        if (!isToUse.markSupported()) {
            isToUse = new BufferedInputStream(isToUse);
            isToUse.mark(1);
        } 
        int code = isToUse.read();
        int major;
        int minor;
        AbstractHessianInput in;
        AbstractHessianOutput out;
        if (code == 'H') {
            major = isToUse.read();
            minor = isToUse.read();
            if (major != 0x02) {
                throw new IOException("Version " + major + '.' + minor + " is not understood");
            } 
            in = new Hessian2Input(isToUse);
            out = new Hessian2Output(osToUse);
            in.readCall();
        } else if (code == 'C') {
            isToUse.reset();
            in = new Hessian2Input(isToUse);
            out = new Hessian2Output(osToUse);
            in.readCall();
        } else if (code == 'c') {
            major = isToUse.read();
            minor = isToUse.read();
            in = new HessianInput(isToUse);
            if (major >= 2) {
                out = new Hessian2Output(osToUse);
            } else {
                out = new HessianOutput(osToUse);
            }
        } else {
            throw new IOException("Expected 'H'/'C' (Hessian 2.0) or 'c' (Hessian 1.0) in hessian input at " + code);
        }
        in.setSerializerFactory(this.serializerFactory);
        out.setSerializerFactory(this.serializerFactory);
        if (this.remoteResolver != null) {
            in.setRemoteResolver(this.remoteResolver);
        } 
        try {
            skeleton.invoke(in, out);
        } finally {
            try {
                in.close();
                isToUse.close();
            } catch (IOException ex) {
            }
            try {
                out.close();
                osToUse.close();
            } catch (IOException ex) {
            }
        }
    } finally {
        resetThreadContextClassLoader(originalClassLoader);
    }
}
org.springframework.remoting.caucho.HessianExporter
public void invoke(InputStream inputStream, OutputStream outputStream)
{
    Assert.notNull(this.skeleton, "Hessian exporter has not been initialized");
    doInvoke(this.skeleton, inputStream, outputStream);
}
org.springframework.remoting.caucho.HessianExporter
public void setAllowNonSerializable(boolean allowNonSerializable)
{
    this.serializerFactory.setAllowNonSerializable(allowNonSerializable);
}
org.springframework.remoting.caucho.HessianExporter
public void setDebug(boolean debug)
{
    this.debugLogger = (debug ? logger : null);
}
org.springframework.remoting.caucho.HessianExporter
public void setRemoteResolver(HessianRemoteResolver remoteResolver)
{
    this.remoteResolver = remoteResolver;
}
org.springframework.remoting.caucho.HessianExporter
public void setSendCollectionType(boolean sendCollectionType)
{
    this.serializerFactory.setSendCollectionType(sendCollectionType);
}
org.springframework.remoting.caucho.HessianExporter
public void setSerializerFactory(@Nullable SerializerFactory serializerFactory)
{
    this.serializerFactory = (serializerFactory != null ? serializerFactory : new SerializerFactory());
}
 HessianProxyFactoryBean
 extends HessianClientInterceptor implements FactoryBean<Object>
org.springframework.remoting.caucho.HessianProxyFactoryBean
@Override public void afterPropertiesSet()
{
    super.afterPropertiesSet();
    this.serviceProxy = new ProxyFactory(getServiceInterface(), this).getProxy(getBeanClassLoader());
}
org.springframework.remoting.caucho.HessianProxyFactoryBean
@Override @Nullable public Object getObject()
{
    return this.serviceProxy;
}
org.springframework.remoting.caucho.HessianProxyFactoryBean
@Override public Class<?> getObjectType()
{
    return getServiceInterface();
}
org.springframework.remoting.caucho.HessianProxyFactoryBean
@Override public boolean isSingleton()
{
    return true;
}
 HessianServiceExporter
 extends HessianExporter implements HttpRequestHandler
org.springframework.remoting.caucho.HessianServiceExporter
@Override public void handleRequest(HttpServletRequest request, HttpServletResponse response)
{
    if (!"POST".equals(request.getMethod())) {
        throw new HttpRequestMethodNotSupportedException(request.getMethod(), new String[]{"POST"}, "HessianServiceExporter only supports POST requests");
    } 
    response.setContentType(CONTENT_TYPE_HESSIAN);
    try {
        invoke(request.getInputStream(), response.getOutputStream());
    } catch (Throwable ex) {
        throw new NestedServletException("Hessian skeleton invocation failed", ex);
    }
}
 SimpleHessianServiceExporter
 extends HessianExporter implements HttpHandler
org.springframework.remoting.caucho.SimpleHessianServiceExporter
@Override public void handle(HttpExchange exchange)
{
    if (!"POST".equals(exchange.getRequestMethod())) {
        exchange.getResponseHeaders().set("Allow", "POST");
        exchange.sendResponseHeaders(405, -1);
        return ;
    } 
    ByteArrayOutputStream output = new ByteArrayOutputStream(1024);
    try {
        invoke(exchange.getRequestBody(), output);
    } catch (Throwable ex) {
        exchange.sendResponseHeaders(500, -1);
        logger.error("Hessian skeleton invocation failed", ex);
        return ;
    }
    exchange.getResponseHeaders().set("Content-Type", CONTENT_TYPE_HESSIAN);
    exchange.sendResponseHeaders(200, output.size());
    FileCopyUtils.copy(output.toByteArray(), exchange.getResponseBody());
}
 AbstractHttpInvokerRequestExecutor
 implements HttpInvokerRequestExecutor, BeanClassLoaderAware
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
public static final String CONTENT_TYPE_SERIALIZED_OBJECT
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
protected static final String ENCODING_GZIP
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
protected static final String HTTP_HEADER_ACCEPT_ENCODING
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
protected static final String HTTP_HEADER_ACCEPT_LANGUAGE
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
protected static final String HTTP_HEADER_CONTENT_ENCODING
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
protected static final String HTTP_HEADER_CONTENT_LENGTH
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
protected static final String HTTP_HEADER_CONTENT_TYPE
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
protected static final String HTTP_METHOD_POST
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
protected ObjectInputStream createObjectInputStream(InputStream is, @Nullable String codebaseUrl)
{
    return new CodebaseAwareObjectInputStream(is, getBeanClassLoader(), codebaseUrl);
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
protected InputStream decorateInputStream(InputStream is)
{
    return is;
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
protected OutputStream decorateOutputStream(OutputStream os)
{
    return os;
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
protected abstract RemoteInvocationResult doExecuteRequest(HttpInvokerClientConfiguration config, ByteArrayOutputStream baos)
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
protected RemoteInvocationResult doReadRemoteInvocationResult(ObjectInputStream ois)
{
    Object obj = ois.readObject();
    if (!(obj instanceof RemoteInvocationResult)) {
        throw new RemoteException("Deserialized object needs to be assignable to type [" + RemoteInvocationResult.class.getName() + "]: " + ClassUtils.getDescriptiveType(obj));
    } 
    return (RemoteInvocationResult)obj;
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
protected void doWriteRemoteInvocation(RemoteInvocation invocation, ObjectOutputStream oos)
{
    oos.writeObject(invocation);
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
@Override public final RemoteInvocationResult executeRequest(HttpInvokerClientConfiguration config, RemoteInvocation invocation)
{
    ByteArrayOutputStream baos = getByteArrayOutputStream(invocation);
    if (logger.isDebugEnabled()) {
        logger.debug("Sending HTTP invoker request for service at [" + config.getServiceUrl() + "], with size " + baos.size());
    } 
    return doExecuteRequest(config, baos);
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
@Nullable protected ClassLoader getBeanClassLoader()
{
    return this.beanClassLoader;
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
protected ByteArrayOutputStream getByteArrayOutputStream(RemoteInvocation invocation)
{
    ByteArrayOutputStream baos = new ByteArrayOutputStream(SERIALIZED_INVOCATION_BYTE_ARRAY_INITIAL_SIZE);
    writeRemoteInvocation(invocation, baos);
    return baos;
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
public String getContentType()
{
    return this.contentType;
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
public boolean isAcceptGzipEncoding()
{
    return this.acceptGzipEncoding;
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
protected final Log logger
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
protected RemoteInvocationResult readRemoteInvocationResult(InputStream is, @Nullable String codebaseUrl)
{
    ObjectInputStream ois = createObjectInputStream(decorateInputStream(is), codebaseUrl);
    try {
        return doReadRemoteInvocationResult(ois);
    } finally {
        ois.close();
    }
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
public void setAcceptGzipEncoding(boolean acceptGzipEncoding)
{
    this.acceptGzipEncoding = acceptGzipEncoding;
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
@Override public void setBeanClassLoader(ClassLoader classLoader)
{
    this.beanClassLoader = classLoader;
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
public void setContentType(String contentType)
{
    Assert.notNull(contentType, "'contentType' must not be null");
    this.contentType = contentType;
}
org.springframework.remoting.httpinvoker.AbstractHttpInvokerRequestExecutor
protected void writeRemoteInvocation(RemoteInvocation invocation, OutputStream os)
{
    ObjectOutputStream oos = new ObjectOutputStream(decorateOutputStream(os));
    try {
        doWriteRemoteInvocation(invocation, oos);
    } finally {
        oos.close();
    }
}
 HttpComponentsHttpInvokerRequestExecutor
 extends AbstractHttpInvokerRequestExecutor
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor
public HttpComponentsHttpInvokerRequestExecutor HttpComponentsHttpInvokerRequestExecutor()
{
    this(createDefaultHttpClient(), RequestConfig.custom().setSocketTimeout(DEFAULT_READ_TIMEOUT_MILLISECONDS).build());
}
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor
public HttpComponentsHttpInvokerRequestExecutor HttpComponentsHttpInvokerRequestExecutor(HttpClient httpClient)
{
    this(httpClient, null);
}
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor
protected HttpPost createHttpPost(HttpInvokerClientConfiguration config)
{
    HttpPost httpPost = new HttpPost(config.getServiceUrl());
    RequestConfig requestConfig = createRequestConfig(config);
    if (requestConfig != null) {
        httpPost.setConfig(requestConfig);
    } 
    LocaleContext localeContext = LocaleContextHolder.getLocaleContext();
    if (localeContext != null) {
        Locale locale = localeContext.getLocale();
        if (locale != null) {
            httpPost.addHeader(HTTP_HEADER_ACCEPT_LANGUAGE, locale.toLanguageTag());
        } 
    } 
    if (isAcceptGzipEncoding()) {
        httpPost.addHeader(HTTP_HEADER_ACCEPT_ENCODING, ENCODING_GZIP);
    } 
    return httpPost;
}
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor
@Nullable protected RequestConfig createRequestConfig(HttpInvokerClientConfiguration config)
{
    HttpClient client = getHttpClient();
    if (client instanceof Configurable) {
        RequestConfig clientRequestConfig = ((Configurable)client).getConfig();
        return mergeRequestConfig(clientRequestConfig);
    } 
    return this.requestConfig;
}
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor
protected HttpResponse executeHttpPost(HttpInvokerClientConfiguration config, HttpClient httpClient, HttpPost httpPost)
{
    return httpClient.execute(httpPost);
}
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor
public HttpClient getHttpClient()
{
    return this.httpClient;
}
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor
protected InputStream getResponseBody(HttpInvokerClientConfiguration config, HttpResponse httpResponse)
{
    if (isGzipResponse(httpResponse)) {
        return new GZIPInputStream(httpResponse.getEntity().getContent());
    } else {
        return httpResponse.getEntity().getContent();
    }
}
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor
public void setConnectTimeout(int timeout)
{
    Assert.isTrue(timeout >= 0, "Timeout must be a non-negative value");
    this.requestConfig = cloneRequestConfig().setConnectTimeout(timeout).build();
}
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor
public void setConnectionRequestTimeout(int connectionRequestTimeout)
{
    this.requestConfig = cloneRequestConfig().setConnectionRequestTimeout(connectionRequestTimeout).build();
}
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor
public void setHttpClient(HttpClient httpClient)
{
    this.httpClient = httpClient;
}
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor
public void setReadTimeout(int timeout)
{
    Assert.isTrue(timeout >= 0, "Timeout must be a non-negative value");
    this.requestConfig = cloneRequestConfig().setSocketTimeout(timeout).build();
}
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor
protected void setRequestBody(HttpInvokerClientConfiguration config, HttpPost httpPost, ByteArrayOutputStream baos)
{
    ByteArrayEntity entity = new ByteArrayEntity(baos.toByteArray());
    entity.setContentType(getContentType());
    httpPost.setEntity(entity);
}
org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor
protected void validateResponse(HttpInvokerClientConfiguration config, HttpResponse response)
{
    StatusLine status = response.getStatusLine();
    if (status.getStatusCode() >= 300) {
        throw new NoHttpResponseException("Did not receive successful HTTP response: status code = " + status.getStatusCode() + ", status message = [" + status.getReasonPhrase() + "]");
    } 
}
 HttpInvokerClientConfiguration
 HttpInvokerClientInterceptor
 extends RemoteInvocationBasedAccessor implements MethodInterceptor, HttpInvokerClientConfiguration
org.springframework.remoting.httpinvoker.HttpInvokerClientInterceptor
@Override public void afterPropertiesSet()
{
    super.afterPropertiesSet();
    getHttpInvokerRequestExecutor();
}
org.springframework.remoting.httpinvoker.HttpInvokerClientInterceptor
@Nullable protected RemoteAccessException convertHttpInvokerAccessException(Throwable ex)
{
    if (ex instanceof ConnectException) {
        return new RemoteConnectFailureException("Could not connect to HTTP invoker remote service at [" + getServiceUrl() + "]", ex);
    } 
    if (ex instanceof ClassNotFoundException || ex instanceof NoClassDefFoundError || ex instanceof InvalidClassException) {
        return new RemoteAccessException("Could not deserialize result from HTTP invoker remote service [" + getServiceUrl() + "]", ex);
    } 
    if (ex instanceof Exception) {
        return new RemoteAccessException("Could not access HTTP invoker remote service at [" + getServiceUrl() + "]", ex);
    } 
    return null;
}
org.springframework.remoting.httpinvoker.HttpInvokerClientInterceptor
protected RemoteInvocationResult executeRequest(RemoteInvocation invocation, MethodInvocation originalInvocation)
{
    return executeRequest(invocation);
}
org.springframework.remoting.httpinvoker.HttpInvokerClientInterceptor
protected RemoteInvocationResult executeRequest(RemoteInvocation invocation)
{
    return getHttpInvokerRequestExecutor().executeRequest(this, invocation);
}
org.springframework.remoting.httpinvoker.HttpInvokerClientInterceptor
@Override @Nullable public String getCodebaseUrl()
{
    return this.codebaseUrl;
}
org.springframework.remoting.httpinvoker.HttpInvokerClientInterceptor
public HttpInvokerRequestExecutor getHttpInvokerRequestExecutor()
{
    if (this.httpInvokerRequestExecutor == null) {
        SimpleHttpInvokerRequestExecutor executor = new SimpleHttpInvokerRequestExecutor();
        executor.setBeanClassLoader(getBeanClassLoader());
        this.httpInvokerRequestExecutor = executor;
    } 
    return this.httpInvokerRequestExecutor;
}
org.springframework.remoting.httpinvoker.HttpInvokerClientInterceptor
public void setCodebaseUrl(@Nullable String codebaseUrl)
{
    this.codebaseUrl = codebaseUrl;
}
org.springframework.remoting.httpinvoker.HttpInvokerClientInterceptor
public void setHttpInvokerRequestExecutor(HttpInvokerRequestExecutor httpInvokerRequestExecutor)
{
    this.httpInvokerRequestExecutor = httpInvokerRequestExecutor;
}
 HttpInvokerProxyFactoryBean
 extends HttpInvokerClientInterceptor implements FactoryBean<Object>
org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean
@Override @Nullable public Object getObject()
{
    return this.serviceProxy;
}
org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean
@Override public Class<?> getObjectType()
{
    return getServiceInterface();
}
org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean
@Override public boolean isSingleton()
{
    return true;
}
 HttpInvokerRequestExecutor
 HttpInvokerServiceExporter
 extends RemoteInvocationSerializingExporter implements HttpRequestHandler
org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter
protected InputStream decorateInputStream(HttpServletRequest request, InputStream is)
{
    return is;
}
org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter
protected OutputStream decorateOutputStream(HttpServletRequest request, HttpServletResponse response, OutputStream os)
{
    return os;
}
org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter
@Override public void handleRequest(HttpServletRequest request, HttpServletResponse response)
{
    try {
        RemoteInvocation invocation = readRemoteInvocation(request);
        RemoteInvocationResult result = invokeAndCreateResult(invocation, getProxy());
        writeRemoteInvocationResult(request, response, result);
    } catch (ClassNotFoundException ex) {
        throw new NestedServletException("Class not found during deserialization", ex);
    }
}
org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter
protected RemoteInvocation readRemoteInvocation(HttpServletRequest request)
{
    return readRemoteInvocation(request, request.getInputStream());
}
org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter
protected RemoteInvocation readRemoteInvocation(HttpServletRequest request, InputStream is)
{
    ObjectInputStream ois = createObjectInputStream(decorateInputStream(request, is));
    try {
        return doReadRemoteInvocation(ois);
    } finally {
        ois.close();
    }
}
org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter
protected void writeRemoteInvocationResult(HttpServletRequest request, HttpServletResponse response, RemoteInvocationResult result)
{
    response.setContentType(getContentType());
    writeRemoteInvocationResult(request, response, result, response.getOutputStream());
}
org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter
protected void writeRemoteInvocationResult(HttpServletRequest request, HttpServletResponse response, RemoteInvocationResult result, OutputStream os)
{
    ObjectOutputStream oos = createObjectOutputStream(new FlushGuardedOutputStream(decorateOutputStream(request, response, os)));
    try {
        doWriteRemoteInvocationResult(result, oos);
    } finally {
        oos.close();
    }
}
 SimpleHttpInvokerRequestExecutor
 extends AbstractHttpInvokerRequestExecutor
org.springframework.remoting.httpinvoker.SimpleHttpInvokerRequestExecutor
@Override protected RemoteInvocationResult doExecuteRequest(HttpInvokerClientConfiguration config, ByteArrayOutputStream baos)
{
    HttpURLConnection con = openConnection(config);
    prepareConnection(con, baos.size());
    writeRequestBody(config, con, baos);
    validateResponse(config, con);
    InputStream responseBody = readResponseBody(config, con);
    return readRemoteInvocationResult(responseBody, config.getCodebaseUrl());
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerRequestExecutor
protected boolean isGzipResponse(HttpURLConnection con)
{
    String encodingHeader = con.getHeaderField(HTTP_HEADER_CONTENT_ENCODING);
    return (encodingHeader != null && encodingHeader.toLowerCase().contains(ENCODING_GZIP));
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerRequestExecutor
protected HttpURLConnection openConnection(HttpInvokerClientConfiguration config)
{
    URLConnection con = new URL(config.getServiceUrl()).openConnection();
    if (!(con instanceof HttpURLConnection)) {
        throw new IOException("Service URL [" + config.getServiceUrl() + "] does not resolve to an HTTP connection");
    } 
    return (HttpURLConnection)con;
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerRequestExecutor
protected void prepareConnection(HttpURLConnection connection, int contentLength)
{
    if (this.connectTimeout >= 0) {
        connection.setConnectTimeout(this.connectTimeout);
    } 
    if (this.readTimeout >= 0) {
        connection.setReadTimeout(this.readTimeout);
    } 
    connection.setDoOutput(true);
    connection.setRequestMethod(HTTP_METHOD_POST);
    connection.setRequestProperty(HTTP_HEADER_CONTENT_TYPE, getContentType());
    connection.setRequestProperty(HTTP_HEADER_CONTENT_LENGTH, Integer.toString(contentLength));
    LocaleContext localeContext = LocaleContextHolder.getLocaleContext();
    if (localeContext != null) {
        Locale locale = localeContext.getLocale();
        if (locale != null) {
            connection.setRequestProperty(HTTP_HEADER_ACCEPT_LANGUAGE, locale.toLanguageTag());
        } 
    } 
    if (isAcceptGzipEncoding()) {
        connection.setRequestProperty(HTTP_HEADER_ACCEPT_ENCODING, ENCODING_GZIP);
    } 
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerRequestExecutor
protected InputStream readResponseBody(HttpInvokerClientConfiguration config, HttpURLConnection con)
{
    if (isGzipResponse(con)) {
        return new GZIPInputStream(con.getInputStream());
    } else {
        return con.getInputStream();
    }
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerRequestExecutor
public void setConnectTimeout(int connectTimeout)
{
    this.connectTimeout = connectTimeout;
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerRequestExecutor
public void setReadTimeout(int readTimeout)
{
    this.readTimeout = readTimeout;
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerRequestExecutor
protected void validateResponse(HttpInvokerClientConfiguration config, HttpURLConnection con)
{
    if (con.getResponseCode() >= 300) {
        throw new IOException("Did not receive successful HTTP response: status code = " + con.getResponseCode() + ", status message = [" + con.getResponseMessage() + "]");
    } 
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerRequestExecutor
protected void writeRequestBody(HttpInvokerClientConfiguration config, HttpURLConnection con, ByteArrayOutputStream baos)
{
    baos.writeTo(con.getOutputStream());
}
 SimpleHttpInvokerServiceExporter
 extends RemoteInvocationSerializingExporter implements HttpHandler
org.springframework.remoting.httpinvoker.SimpleHttpInvokerServiceExporter
protected InputStream decorateInputStream(HttpExchange exchange, InputStream is)
{
    return is;
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerServiceExporter
protected OutputStream decorateOutputStream(HttpExchange exchange, OutputStream os)
{
    return os;
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerServiceExporter
protected RemoteInvocation readRemoteInvocation(HttpExchange exchange)
{
    return readRemoteInvocation(exchange, exchange.getRequestBody());
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerServiceExporter
protected RemoteInvocation readRemoteInvocation(HttpExchange exchange, InputStream is)
{
    ObjectInputStream ois = createObjectInputStream(decorateInputStream(exchange, is));
    return doReadRemoteInvocation(ois);
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerServiceExporter
protected void writeRemoteInvocationResult(HttpExchange exchange, RemoteInvocationResult result)
{
    exchange.getResponseHeaders().set("Content-Type", getContentType());
    exchange.sendResponseHeaders(200, 0);
    writeRemoteInvocationResult(exchange, result, exchange.getResponseBody());
}
org.springframework.remoting.httpinvoker.SimpleHttpInvokerServiceExporter
protected void writeRemoteInvocationResult(HttpExchange exchange, RemoteInvocationResult result, OutputStream os)
{
    ObjectOutputStream oos = createObjectOutputStream(decorateOutputStream(exchange, os));
    doWriteRemoteInvocationResult(result, oos);
    oos.flush();
}
 AbstractJaxWsServiceExporter
 implements BeanFactoryAware, InitializingBean, DisposableBean
org.springframework.remoting.jaxws.AbstractJaxWsServiceExporter
@Override public void afterPropertiesSet()
{
    publishEndpoints();
}
org.springframework.remoting.jaxws.AbstractJaxWsServiceExporter
protected Endpoint createEndpoint(Object bean)
{
    return (this.endpointFeatures != null ? Endpoint.create(this.bindingType, bean, this.endpointFeatures) : Endpoint.create(this.bindingType, bean));
}
org.springframework.remoting.jaxws.AbstractJaxWsServiceExporter
@Override public void destroy()
{
    for (Endpoint endpoint: this.publishedEndpoints) {
        endpoint.stop();
    }
}
org.springframework.remoting.jaxws.AbstractJaxWsServiceExporter
protected abstract void publishEndpoint(Endpoint endpoint, WebService annotation)
org.springframework.remoting.jaxws.AbstractJaxWsServiceExporter
protected abstract void publishEndpoint(Endpoint endpoint, WebServiceProvider annotation)
org.springframework.remoting.jaxws.AbstractJaxWsServiceExporter
@Override public void setBeanFactory(BeanFactory beanFactory)
{
    if (!(beanFactory instanceof ListableBeanFactory)) {
        throw new IllegalStateException(getClass().getSimpleName() + " requires a ListableBeanFactory");
    } 
    this.beanFactory = (ListableBeanFactory)beanFactory;
}
org.springframework.remoting.jaxws.AbstractJaxWsServiceExporter
public void setBindingType(String bindingType)
{
    this.bindingType = bindingType;
}
org.springframework.remoting.jaxws.AbstractJaxWsServiceExporter
public void setEndpointFeatures(WebServiceFeature... endpointFeatures)
{
    this.endpointFeatures = endpointFeatures;
}
org.springframework.remoting.jaxws.AbstractJaxWsServiceExporter
public void setEndpointProperties(Map<String, Object> endpointProperties)
{
    this.endpointProperties = endpointProperties;
}
org.springframework.remoting.jaxws.AbstractJaxWsServiceExporter
public void setExecutor(Executor executor)
{
    this.executor = executor;
}
 JaxWsPortClientInterceptor
 extends LocalJaxWsServiceFactory implements MethodInterceptor, BeanClassLoaderAware, InitializingBean
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
public void addCustomProperty(String name, Object value)
{
    getCustomProperties().put(name, value);
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
@Override public void afterPropertiesSet()
{
    if (this.lookupServiceOnStartup) {
        prepare();
    } 
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
@Nullable protected Object doInvoke(MethodInvocation invocation)
{
    try {
        return doInvoke(invocation, getPortStub());
    } catch (SOAPFaultException ex) {
        throw new JaxWsSoapFaultException(ex);
    } catch (ProtocolException ex) {
        throw new RemoteConnectFailureException("Could not connect to remote service [" + getEndpointAddress() + "]", ex);
    } catch (WebServiceException ex) {
        throw new RemoteAccessException("Could not access remote service at [" + getEndpointAddress() + "]", ex);
    }
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
@Nullable protected Object doInvoke(MethodInvocation invocation, @Nullable Object portStub)
{
    Method method = invocation.getMethod();
    try {
        return method.invoke(portStub, invocation.getArguments());
    } catch (InvocationTargetException ex) {
        throw ex.getTargetException();
    } catch (Throwable ex) {
        throw new RemoteProxyFailureException("Invocation of stub method failed: " + method, ex);
    }
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
@Nullable protected ClassLoader getBeanClassLoader()
{
    return this.beanClassLoader;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
public Map<String, Object> getCustomProperties()
{
    if (this.customProperties == null) {
        this.customProperties = new HashMap<>();
    } 
    return this.customProperties;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
@Nullable public String getEndpointAddress()
{
    return this.endpointAddress;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
@Nullable public Service getJaxWsService()
{
    return this.jaxWsService;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
@Nullable public String getPassword()
{
    return this.password;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
@Nullable public String getPortName()
{
    return this.portName;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
@Nullable protected final QName getPortQName()
{
    return this.portQName;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
@Nullable protected Object getPortStub()
{
    return this.portStub;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
@Nullable public Class<?> getServiceInterface()
{
    return this.serviceInterface;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
@Nullable public String getSoapActionUri()
{
    return this.soapActionUri;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
@Nullable public String getUsername()
{
    return this.username;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
@Override @Nullable public Object invoke(MethodInvocation invocation)
{
    if (AopUtils.isToStringMethod(invocation.getMethod())) {
        return "JAX-WS proxy for port [" + getPortName() + "] of service [" + getServiceName() + "]";
    } 
    synchronized(this.preparationMonitor) {
        if (!isPrepared()) {
            prepare();
        } 
    }
    return doInvoke(invocation);
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
public boolean isMaintainSession()
{
    return this.maintainSession;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
protected boolean isPrepared()
{
    synchronized(this.preparationMonitor) {
        return (this.portStub != null);
    }
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
public boolean isUseSoapAction()
{
    return this.useSoapAction;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
public void prepare()
{
    Class<?> ifc = getServiceInterface();
    Assert.notNull(ifc, "Property 'serviceInterface' is required");
    WebService ann = ifc.getAnnotation(WebService.class);
    if (ann != null) {
        applyDefaultsFromAnnotation(ann);
    } 
    Service serviceToUse = getJaxWsService();
    if (serviceToUse == null) {
        serviceToUse = createJaxWsService();
    } 
    this.portQName = getQName(getPortName() != null ? getPortName() : ifc.getName());
    Object stub = getPortStub(serviceToUse, (getPortName() != null ? this.portQName : null));
    preparePortStub(stub);
    this.portStub = stub;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
@Override public void setBeanClassLoader(@Nullable ClassLoader classLoader)
{
    this.beanClassLoader = classLoader;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
public void setCustomProperties(Map<String, Object> customProperties)
{
    this.customProperties = customProperties;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
public void setEndpointAddress(@Nullable String endpointAddress)
{
    this.endpointAddress = endpointAddress;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
public void setJaxWsService(@Nullable Service jaxWsService)
{
    this.jaxWsService = jaxWsService;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
public void setLookupServiceOnStartup(boolean lookupServiceOnStartup)
{
    this.lookupServiceOnStartup = lookupServiceOnStartup;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
public void setMaintainSession(boolean maintainSession)
{
    this.maintainSession = maintainSession;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
public void setPassword(@Nullable String password)
{
    this.password = password;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
public void setPortFeatures(WebServiceFeature... features)
{
    this.portFeatures = features;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
public void setPortName(@Nullable String portName)
{
    this.portName = portName;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
public void setServiceInterface(@Nullable Class<?> serviceInterface)
{
    if (serviceInterface != null) {
        Assert.isTrue(serviceInterface.isInterface(), "'serviceInterface' must be an interface");
    } 
    this.serviceInterface = serviceInterface;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
public void setSoapActionUri(@Nullable String soapActionUri)
{
    this.soapActionUri = soapActionUri;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
public void setUseSoapAction(boolean useSoapAction)
{
    this.useSoapAction = useSoapAction;
}
org.springframework.remoting.jaxws.JaxWsPortClientInterceptor
public void setUsername(@Nullable String username)
{
    this.username = username;
}
 JaxWsPortProxyFactoryBean
 extends JaxWsPortClientInterceptor implements FactoryBean<Object>
org.springframework.remoting.jaxws.JaxWsPortProxyFactoryBean
@Override @Nullable public Object getObject()
{
    return this.serviceProxy;
}
org.springframework.remoting.jaxws.JaxWsPortProxyFactoryBean
@Override public Class<?> getObjectType()
{
    return getServiceInterface();
}
org.springframework.remoting.jaxws.JaxWsPortProxyFactoryBean
@Override public boolean isSingleton()
{
    return true;
}
 JaxWsSoapFaultException
 extends SoapFaultException
org.springframework.remoting.jaxws.JaxWsSoapFaultException
public JaxWsSoapFaultException JaxWsSoapFaultException(SOAPFaultException original)
{
    super(original.getMessage(), original);
}
org.springframework.remoting.jaxws.JaxWsSoapFaultException
public final SOAPFault getFault()
{
    return ((SOAPFaultException)getCause()).getFault();
}
org.springframework.remoting.jaxws.JaxWsSoapFaultException
@Override public String getFaultActor()
{
    return getFault().getFaultActor();
}
org.springframework.remoting.jaxws.JaxWsSoapFaultException
@Override public String getFaultCode()
{
    return getFault().getFaultCode();
}
org.springframework.remoting.jaxws.JaxWsSoapFaultException
@Override public QName getFaultCodeAsQName()
{
    return getFault().getFaultCodeAsQName();
}
org.springframework.remoting.jaxws.JaxWsSoapFaultException
@Override public String getFaultString()
{
    return getFault().getFaultString();
}
 LocalJaxWsServiceFactory
org.springframework.remoting.jaxws.LocalJaxWsServiceFactory
@Nullable public String getNamespaceUri()
{
    return this.namespaceUri;
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactory
protected QName getQName(String name)
{
    return (getNamespaceUri() != null ? new QName(getNamespaceUri(), name) : new QName(name));
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactory
@Nullable public String getServiceName()
{
    return this.serviceName;
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactory
@Nullable public URL getWsdlDocumentUrl()
{
    return this.wsdlDocumentUrl;
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactory
public void setExecutor(Executor executor)
{
    this.executor = executor;
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactory
public void setHandlerResolver(HandlerResolver handlerResolver)
{
    this.handlerResolver = handlerResolver;
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactory
public void setNamespaceUri(@Nullable String namespaceUri)
{
    this.namespaceUri = (namespaceUri != null ? namespaceUri.trim() : null);
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactory
public void setServiceFeatures(WebServiceFeature... serviceFeatures)
{
    this.serviceFeatures = serviceFeatures;
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactory
public void setServiceName(@Nullable String serviceName)
{
    this.serviceName = serviceName;
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactory
public void setWsdlDocumentResource(Resource wsdlDocumentResource)
{
    Assert.notNull(wsdlDocumentResource, "WSDL Resource must not be null");
    this.wsdlDocumentUrl = wsdlDocumentResource.getURL();
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactory
public void setWsdlDocumentUrl(@Nullable URL wsdlDocumentUrl)
{
    this.wsdlDocumentUrl = wsdlDocumentUrl;
}
 LocalJaxWsServiceFactoryBean
 extends LocalJaxWsServiceFactory implements FactoryBean<Service>, InitializingBean
org.springframework.remoting.jaxws.LocalJaxWsServiceFactoryBean
@Override public void afterPropertiesSet()
{
    this.service = createJaxWsService();
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactoryBean
@Override @Nullable public Service getObject()
{
    return this.service;
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactoryBean
@Override public Class<?> getObjectType()
{
    return (this.service != null ? this.service.getClass() : Service.class);
}
org.springframework.remoting.jaxws.LocalJaxWsServiceFactoryBean
@Override public boolean isSingleton()
{
    return true;
}
 SimpleHttpServerJaxWsServiceExporter
 extends AbstractJaxWsServiceExporter
org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter
protected String calculateEndpointPath(Endpoint endpoint, String serviceName)
{
    return this.basePath + serviceName;
}
org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter
@Override public void destroy()
{
    super.destroy();
    if (this.server != null && this.localServer) {
        logger.info("Stopping HttpServer");
        this.server.stop(this.shutdownDelay);
    } 
}
org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter
protected final Log logger
org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter
@Override protected void publishEndpoint(Endpoint endpoint, WebService annotation)
{
    endpoint.publish(buildHttpContext(endpoint, annotation.serviceName()));
}
org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter
@Override protected void publishEndpoint(Endpoint endpoint, WebServiceProvider annotation)
{
    endpoint.publish(buildHttpContext(endpoint, annotation.serviceName()));
}
org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter
public void setAuthenticator(Authenticator authenticator)
{
    this.authenticator = authenticator;
}
org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter
public void setBacklog(int backlog)
{
    this.backlog = backlog;
}
org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter
public void setBasePath(String basePath)
{
    this.basePath = basePath;
}
org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter
public void setFilters(List<Filter> filters)
{
    this.filters = filters;
}
org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter
public void setHostname(String hostname)
{
    this.hostname = hostname;
}
org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter
public void setPort(int port)
{
    this.port = port;
}
org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter
public void setServer(HttpServer server)
{
    this.server = server;
}
org.springframework.remoting.jaxws.SimpleHttpServerJaxWsServiceExporter
public void setShutdownDelay(int shutdownDelay)
{
    this.shutdownDelay = shutdownDelay;
}
 SimpleJaxWsServiceExporter
 extends AbstractJaxWsServiceExporter
org.springframework.remoting.jaxws.SimpleJaxWsServiceExporter
public static final String DEFAULT_BASE_ADDRESS
org.springframework.remoting.jaxws.SimpleJaxWsServiceExporter
protected String calculateEndpointAddress(Endpoint endpoint, String serviceName)
{
    String fullAddress = this.baseAddress + serviceName;
    if (endpoint.getClass().getName().startsWith("weblogic.")) {
        fullAddress = fullAddress + "/";
    } 
    return fullAddress;
}
org.springframework.remoting.jaxws.SimpleJaxWsServiceExporter
@Override protected void publishEndpoint(Endpoint endpoint, WebService annotation)
{
    endpoint.publish(calculateEndpointAddress(endpoint, annotation.serviceName()));
}
org.springframework.remoting.jaxws.SimpleJaxWsServiceExporter
@Override protected void publishEndpoint(Endpoint endpoint, WebServiceProvider annotation)
{
    endpoint.publish(calculateEndpointAddress(endpoint, annotation.serviceName()));
}
org.springframework.remoting.jaxws.SimpleJaxWsServiceExporter
public void setBaseAddress(String baseAddress)
{
    this.baseAddress = baseAddress;
}
 HttpMediaTypeException
 extends ServletException
org.springframework.web.HttpMediaTypeException
protected HttpMediaTypeException HttpMediaTypeException(String message)
{
    super(message);
    this.supportedMediaTypes = Collections.emptyList();
}
org.springframework.web.HttpMediaTypeException
protected HttpMediaTypeException HttpMediaTypeException(String message, List<MediaType> supportedMediaTypes)
{
    super(message);
    this.supportedMediaTypes = Collections.unmodifiableList(supportedMediaTypes);
}
org.springframework.web.HttpMediaTypeException
public List<MediaType> getSupportedMediaTypes()
{
    return this.supportedMediaTypes;
}
 HttpMediaTypeNotAcceptableException
 extends HttpMediaTypeException
org.springframework.web.HttpMediaTypeNotAcceptableException
public HttpMediaTypeNotAcceptableException HttpMediaTypeNotAcceptableException(String message)
{
    super(message);
}
org.springframework.web.HttpMediaTypeNotAcceptableException
public HttpMediaTypeNotAcceptableException HttpMediaTypeNotAcceptableException(List<MediaType> supportedMediaTypes)
{
    super("Could not find acceptable representation", supportedMediaTypes);
}
 HttpMediaTypeNotSupportedException
 extends HttpMediaTypeException
org.springframework.web.HttpMediaTypeNotSupportedException
public HttpMediaTypeNotSupportedException HttpMediaTypeNotSupportedException(String message)
{
    super(message);
    this.contentType = null;
}
org.springframework.web.HttpMediaTypeNotSupportedException
public HttpMediaTypeNotSupportedException HttpMediaTypeNotSupportedException(@Nullable MediaType contentType, List<MediaType> supportedMediaTypes)
{
    this(contentType, supportedMediaTypes, "Content type '" + (contentType != null ? contentType : "") + "' not supported");
}
org.springframework.web.HttpMediaTypeNotSupportedException
public HttpMediaTypeNotSupportedException HttpMediaTypeNotSupportedException(@Nullable MediaType contentType, List<MediaType> supportedMediaTypes, String msg)
{
    super(msg, supportedMediaTypes);
    this.contentType = contentType;
}
org.springframework.web.HttpMediaTypeNotSupportedException
@Nullable public MediaType getContentType()
{
    return this.contentType;
}
 HttpRequestHandler
 HttpRequestMethodNotSupportedException
 extends ServletException
org.springframework.web.HttpRequestMethodNotSupportedException
public HttpRequestMethodNotSupportedException HttpRequestMethodNotSupportedException(String method)
{
    this(method, (String[])null);
}
org.springframework.web.HttpRequestMethodNotSupportedException
public HttpRequestMethodNotSupportedException HttpRequestMethodNotSupportedException(String method, String msg)
{
    this(method, null, msg);
}
org.springframework.web.HttpRequestMethodNotSupportedException
public HttpRequestMethodNotSupportedException HttpRequestMethodNotSupportedException(String method, @Nullable Collection<String> supportedMethods)
{
    this(method, (supportedMethods != null ? StringUtils.toStringArray(supportedMethods) : null));
}
org.springframework.web.HttpRequestMethodNotSupportedException
public HttpRequestMethodNotSupportedException HttpRequestMethodNotSupportedException(String method, @Nullable String[] supportedMethods)
{
    this(method, supportedMethods, "Request method '" + method + "' not supported");
}
org.springframework.web.HttpRequestMethodNotSupportedException
public HttpRequestMethodNotSupportedException HttpRequestMethodNotSupportedException(String method, @Nullable String[] supportedMethods, String msg)
{
    super(msg);
    this.method = method;
    this.supportedMethods = supportedMethods;
}
org.springframework.web.HttpRequestMethodNotSupportedException
public String getMethod()
{
    return this.method;
}
org.springframework.web.HttpRequestMethodNotSupportedException
@Nullable public Set<HttpMethod> getSupportedHttpMethods()
{
    if (this.supportedMethods == null) {
        return null;
    } 
    List<HttpMethod> supportedMethods = new LinkedList<>();
    for (String value: this.supportedMethods) {
        HttpMethod resolved = HttpMethod.resolve(value);
        if (resolved != null) {
            supportedMethods.add(resolved);
        } 
    }
    return EnumSet.copyOf(supportedMethods);
}
org.springframework.web.HttpRequestMethodNotSupportedException
@Nullable public String[] getSupportedMethods()
{
    return this.supportedMethods;
}
 HttpSessionRequiredException
 extends ServletException
org.springframework.web.HttpSessionRequiredException
public HttpSessionRequiredException HttpSessionRequiredException(String msg)
{
    super(msg);
    this.expectedAttribute = null;
}
org.springframework.web.HttpSessionRequiredException
public HttpSessionRequiredException HttpSessionRequiredException(String msg, String expectedAttribute)
{
    super(msg);
    this.expectedAttribute = expectedAttribute;
}
org.springframework.web.HttpSessionRequiredException
@Nullable public String getExpectedAttribute()
{
    return this.expectedAttribute;
}
 SpringServletContainerInitializer
 implements ServletContainerInitializer
org.springframework.web.SpringServletContainerInitializer
@Override public void onStartup(@Nullable Set<Class<?>> webAppInitializerClasses, ServletContext servletContext)
{
    List<WebApplicationInitializer> initializers = new LinkedList<>();
    if (webAppInitializerClasses != null) {
        for (Class<?> waiClass: webAppInitializerClasses) {
            if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) && WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
                try {
                    initializers.add((WebApplicationInitializer)ReflectionUtils.accessibleConstructor(waiClass).newInstance());
                } catch (Throwable ex) {
                    throw new ServletException("Failed to instantiate WebApplicationInitializer class", ex);
                }
            } 
        }
    } 
    if (initializers.isEmpty()) {
        servletContext.log("No Spring WebApplicationInitializer types detected on classpath");
        return ;
    } 
    servletContext.log(initializers.size() + " Spring WebApplicationInitializers detected on classpath");
    AnnotationAwareOrderComparator.sort(initializers);
    for (WebApplicationInitializer initializer: initializers) {
        initializer.onStartup(servletContext);
    }
}
 WebApplicationInitializer
 AbstractMappingContentNegotiationStrategy
 extends MappingMediaTypeFileExtensionResolver implements ContentNegotiationStrategy
org.springframework.web.accept.AbstractMappingContentNegotiationStrategy
public AbstractMappingContentNegotiationStrategy AbstractMappingContentNegotiationStrategy(@Nullable Map<String, MediaType> mediaTypes)
{
    super(mediaTypes);
}
org.springframework.web.accept.AbstractMappingContentNegotiationStrategy
@Nullable protected abstract String getMediaTypeKey(NativeWebRequest request)
org.springframework.web.accept.AbstractMappingContentNegotiationStrategy
protected void handleMatch(String key, MediaType mediaType)
{
}
org.springframework.web.accept.AbstractMappingContentNegotiationStrategy
@Nullable protected MediaType handleNoMatch(NativeWebRequest request, String key)
{
    if (!isUseRegisteredExtensionsOnly()) {
        Optional<MediaType> mediaType = MediaTypeFactory.getMediaType("file." + key);
        if (mediaType.isPresent()) {
            return mediaType.get();
        } 
    } 
    if (isIgnoreUnknownExtensions()) {
        return null;
    } 
    throw new HttpMediaTypeNotAcceptableException(getAllMediaTypes());
}
org.springframework.web.accept.AbstractMappingContentNegotiationStrategy
public boolean isIgnoreUnknownExtensions()
{
    return this.ignoreUnknownExtensions;
}
org.springframework.web.accept.AbstractMappingContentNegotiationStrategy
public boolean isUseRegisteredExtensionsOnly()
{
    return this.useRegisteredExtensionsOnly;
}
org.springframework.web.accept.AbstractMappingContentNegotiationStrategy
protected final Log logger
org.springframework.web.accept.AbstractMappingContentNegotiationStrategy
public List<MediaType> resolveMediaTypeKey(NativeWebRequest webRequest, @Nullable String key)
{
    if (StringUtils.hasText(key)) {
        MediaType mediaType = lookupMediaType(key);
        if (mediaType != null) {
            handleMatch(key, mediaType);
            return Collections.singletonList(mediaType);
        } 
        mediaType = handleNoMatch(webRequest, key);
        if (mediaType != null) {
            addMapping(key, mediaType);
            return Collections.singletonList(mediaType);
        } 
    } 
    return MEDIA_TYPE_ALL_LIST;
}
org.springframework.web.accept.AbstractMappingContentNegotiationStrategy
@Override public List<MediaType> resolveMediaTypes(NativeWebRequest webRequest)
{
    return resolveMediaTypeKey(webRequest, getMediaTypeKey(webRequest));
}
org.springframework.web.accept.AbstractMappingContentNegotiationStrategy
public void setIgnoreUnknownExtensions(boolean ignoreUnknownExtensions)
{
    this.ignoreUnknownExtensions = ignoreUnknownExtensions;
}
org.springframework.web.accept.AbstractMappingContentNegotiationStrategy
public void setUseRegisteredExtensionsOnly(boolean useRegisteredExtensionsOnly)
{
    this.useRegisteredExtensionsOnly = useRegisteredExtensionsOnly;
}
 ContentNegotiationManager
 implements ContentNegotiationStrategy, MediaTypeFileExtensionResolver
org.springframework.web.accept.ContentNegotiationManager
public ContentNegotiationManager ContentNegotiationManager(ContentNegotiationStrategy... strategies)
{
    this(Arrays.asList(strategies));
}
org.springframework.web.accept.ContentNegotiationManager
public ContentNegotiationManager ContentNegotiationManager()
{
    this(new HeaderContentNegotiationStrategy());
}
org.springframework.web.accept.ContentNegotiationManager
public void addFileExtensionResolvers(MediaTypeFileExtensionResolver... resolvers)
{
    Collections.addAll(this.resolvers, resolvers);
}
org.springframework.web.accept.ContentNegotiationManager
@Override public List<String> getAllFileExtensions()
{
    Set<String> result = new LinkedHashSet<>();
    for (MediaTypeFileExtensionResolver resolver: this.resolvers) {
        result.addAll(resolver.getAllFileExtensions());
    }
    return new ArrayList<>(result);
}
org.springframework.web.accept.ContentNegotiationManager
public List<ContentNegotiationStrategy> getStrategies()
{
    return this.strategies;
}
org.springframework.web.accept.ContentNegotiationManager
<T>@SuppressWarnings("unchecked") @Nullable public T getStrategy(Class<T> strategyType)
{
    for (ContentNegotiationStrategy strategy: getStrategies()) {
        if (strategyType.isInstance(strategy)) {
            return (T)strategy;
        } 
    }
    return null;
}
org.springframework.web.accept.ContentNegotiationManager
@Override public List<String> resolveFileExtensions(MediaType mediaType)
{
    Set<String> result = new LinkedHashSet<>();
    for (MediaTypeFileExtensionResolver resolver: this.resolvers) {
        result.addAll(resolver.resolveFileExtensions(mediaType));
    }
    return new ArrayList<>(result);
}
org.springframework.web.accept.ContentNegotiationManager
@Override public List<MediaType> resolveMediaTypes(NativeWebRequest request)
{
    for (ContentNegotiationStrategy strategy: this.strategies) {
        List<MediaType> mediaTypes = strategy.resolveMediaTypes(request);
        if (mediaTypes.equals(MEDIA_TYPE_ALL_LIST)) {
            continue;
        } 
        return mediaTypes;
    }
    return MEDIA_TYPE_ALL_LIST;
}
 ContentNegotiationManagerFactoryBean
 implements FactoryBean<ContentNegotiationManager>, ServletContextAware, InitializingBean
org.springframework.web.accept.ContentNegotiationManagerFactoryBean
public void addMediaType(String fileExtension, MediaType mediaType)
{
    this.mediaTypes.put(fileExtension, mediaType);
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean
public void addMediaTypes(@Nullable Map<String, MediaType> mediaTypes)
{
    if (mediaTypes != null) {
        this.mediaTypes.putAll(mediaTypes);
    } 
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean
@Override public void afterPropertiesSet()
{
    build();
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean
public ContentNegotiationManager build()
{
    List<ContentNegotiationStrategy> strategies = new ArrayList<>();
    if (this.strategies != null) {
        strategies.addAll(this.strategies);
    } else {
        if (this.favorPathExtension) {
            PathExtensionContentNegotiationStrategy strategy;
            if (this.servletContext != null && !useRegisteredExtensionsOnly()) {
                strategy = new ServletPathExtensionContentNegotiationStrategy(this.servletContext, this.mediaTypes);
            } else {
                strategy = new PathExtensionContentNegotiationStrategy(this.mediaTypes);
            }
            strategy.setIgnoreUnknownExtensions(this.ignoreUnknownPathExtensions);
            if (this.useRegisteredExtensionsOnly != null) {
                strategy.setUseRegisteredExtensionsOnly(this.useRegisteredExtensionsOnly);
            } 
            strategies.add(strategy);
        } 
        if (this.favorParameter) {
            ParameterContentNegotiationStrategy strategy = new ParameterContentNegotiationStrategy(this.mediaTypes);
            strategy.setParameterName(this.parameterName);
            if (this.useRegisteredExtensionsOnly != null) {
                strategy.setUseRegisteredExtensionsOnly(this.useRegisteredExtensionsOnly);
            } else {
                strategy.setUseRegisteredExtensionsOnly(true);
            }
            strategies.add(strategy);
        } 
        if (!this.ignoreAcceptHeader) {
            strategies.add(new HeaderContentNegotiationStrategy());
        } 
        if (this.defaultNegotiationStrategy != null) {
            strategies.add(this.defaultNegotiationStrategy);
        } 
    }
    this.contentNegotiationManager = new ContentNegotiationManager(strategies);
    return this.contentNegotiationManager;
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean
@Override @Nullable public ContentNegotiationManager getObject()
{
    return this.contentNegotiationManager;
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean
@Override public Class<?> getObjectType()
{
    return ContentNegotiationManager.class;
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean
@Override public boolean isSingleton()
{
    return true;
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean
public void setDefaultContentType(MediaType contentType)
{
    this.defaultNegotiationStrategy = new FixedContentNegotiationStrategy(contentType);
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean
public void setDefaultContentTypeStrategy(ContentNegotiationStrategy strategy)
{
    this.defaultNegotiationStrategy = strategy;
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean
public void setDefaultContentTypes(List<MediaType> contentTypes)
{
    this.defaultNegotiationStrategy = new FixedContentNegotiationStrategy(contentTypes);
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean
public void setFavorParameter(boolean favorParameter)
{
    this.favorParameter = favorParameter;
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean
public void setFavorPathExtension(boolean favorPathExtension)
{
    this.favorPathExtension = favorPathExtension;
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean
public void setIgnoreAcceptHeader(boolean ignoreAcceptHeader)
{
    this.ignoreAcceptHeader = ignoreAcceptHeader;
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean
public void setIgnoreUnknownPathExtensions(boolean ignore)
{
    this.ignoreUnknownPathExtensions = ignore;
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean
public void setParameterName(String parameterName)
{
    Assert.notNull(parameterName, "parameterName is required");
    this.parameterName = parameterName;
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean
@Override public void setServletContext(ServletContext servletContext)
{
    this.servletContext = servletContext;
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean
public void setStrategies(@Nullable List<ContentNegotiationStrategy> strategies)
{
    this.strategies = (strategies != null ? new ArrayList<>(strategies) : null);
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean
@Deprecated public void setUseJaf(boolean useJaf)
{
    setUseRegisteredExtensionsOnly(!useJaf);
}
org.springframework.web.accept.ContentNegotiationManagerFactoryBean
public void setUseRegisteredExtensionsOnly(boolean useRegisteredExtensionsOnly)
{
    this.useRegisteredExtensionsOnly = useRegisteredExtensionsOnly;
}
 ContentNegotiationStrategy
 FixedContentNegotiationStrategy
 implements ContentNegotiationStrategy
org.springframework.web.accept.FixedContentNegotiationStrategy
public FixedContentNegotiationStrategy FixedContentNegotiationStrategy(MediaType contentType)
{
    this(Collections.singletonList(contentType));
}
org.springframework.web.accept.FixedContentNegotiationStrategy
public FixedContentNegotiationStrategy FixedContentNegotiationStrategy(List<MediaType> contentTypes)
{
    Assert.notNull(contentTypes, "'contentTypes' must not be null");
    this.contentTypes = Collections.unmodifiableList(contentTypes);
}
org.springframework.web.accept.FixedContentNegotiationStrategy
public List<MediaType> getContentTypes()
{
    return this.contentTypes;
}
org.springframework.web.accept.FixedContentNegotiationStrategy
@Override public List<MediaType> resolveMediaTypes(NativeWebRequest request)
{
    return this.contentTypes;
}
 HeaderContentNegotiationStrategy
 implements ContentNegotiationStrategy
 MappingMediaTypeFileExtensionResolver
 implements MediaTypeFileExtensionResolver
org.springframework.web.accept.MappingMediaTypeFileExtensionResolver
public MappingMediaTypeFileExtensionResolver MappingMediaTypeFileExtensionResolver(@Nullable Map<String, MediaType> mediaTypes)
{
    if (mediaTypes != null) {
        List<String> allFileExtensions = new ArrayList<>();
        mediaTypes.forEach((extension, mediaType) -> {
            String lowerCaseExtension = extension.toLowerCase(Locale.ENGLISH);
            this.mediaTypes.put(lowerCaseExtension, mediaType);
            addFileExtension(mediaType, lowerCaseExtension);
            allFileExtensions.add(lowerCaseExtension);
        });
        this.allFileExtensions.addAll(allFileExtensions);
    } 
}
org.springframework.web.accept.MappingMediaTypeFileExtensionResolver
protected void addMapping(String extension, MediaType mediaType)
{
    MediaType previous = this.mediaTypes.putIfAbsent(extension, mediaType);
    if (previous == null) {
        addFileExtension(mediaType, extension);
        this.allFileExtensions.add(extension);
    } 
}
org.springframework.web.accept.MappingMediaTypeFileExtensionResolver
@Override public List<String> getAllFileExtensions()
{
    return Collections.unmodifiableList(this.allFileExtensions);
}
org.springframework.web.accept.MappingMediaTypeFileExtensionResolver
protected List<MediaType> getAllMediaTypes()
{
    return new ArrayList<>(this.mediaTypes.values());
}
org.springframework.web.accept.MappingMediaTypeFileExtensionResolver
public Map<String, MediaType> getMediaTypes()
{
    return this.mediaTypes;
}
org.springframework.web.accept.MappingMediaTypeFileExtensionResolver
@Nullable protected MediaType lookupMediaType(String extension)
{
    return this.mediaTypes.get(extension.toLowerCase(Locale.ENGLISH));
}
org.springframework.web.accept.MappingMediaTypeFileExtensionResolver
@Override public List<String> resolveFileExtensions(MediaType mediaType)
{
    List<String> fileExtensions = this.fileExtensions.get(mediaType);
    return (fileExtensions != null ? fileExtensions : Collections.emptyList());
}
 MediaTypeFileExtensionResolver
 ParameterContentNegotiationStrategy
 extends AbstractMappingContentNegotiationStrategy
org.springframework.web.accept.ParameterContentNegotiationStrategy
public ParameterContentNegotiationStrategy ParameterContentNegotiationStrategy(Map<String, MediaType> mediaTypes)
{
    super(mediaTypes);
}
org.springframework.web.accept.ParameterContentNegotiationStrategy
@Override @Nullable protected String getMediaTypeKey(NativeWebRequest request)
{
    return request.getParameter(getParameterName());
}
org.springframework.web.accept.ParameterContentNegotiationStrategy
public String getParameterName()
{
    return this.parameterName;
}
org.springframework.web.accept.ParameterContentNegotiationStrategy
public void setParameterName(String parameterName)
{
    Assert.notNull(parameterName, "'parameterName' is required");
    this.parameterName = parameterName;
}
 PathExtensionContentNegotiationStrategy
 extends AbstractMappingContentNegotiationStrategy
org.springframework.web.accept.PathExtensionContentNegotiationStrategy
public PathExtensionContentNegotiationStrategy PathExtensionContentNegotiationStrategy()
{
    this(null);
}
org.springframework.web.accept.PathExtensionContentNegotiationStrategy
public PathExtensionContentNegotiationStrategy PathExtensionContentNegotiationStrategy(@Nullable Map<String, MediaType> mediaTypes)
{
    super(mediaTypes);
    setUseRegisteredExtensionsOnly(false);
    setIgnoreUnknownExtensions(true);
    this.urlPathHelper.setUrlDecode(false);
}
org.springframework.web.accept.PathExtensionContentNegotiationStrategy
@Override @Nullable protected String getMediaTypeKey(NativeWebRequest webRequest)
{
    HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
    if (request == null) {
        return null;
    } 
    String path = this.urlPathHelper.getLookupPathForRequest(request);
    String extension = UriUtils.extractFileExtension(path);
    return (StringUtils.hasText(extension) ? extension.toLowerCase(Locale.ENGLISH) : null);
}
org.springframework.web.accept.PathExtensionContentNegotiationStrategy
public void setUrlPathHelper(UrlPathHelper urlPathHelper)
{
    this.urlPathHelper = urlPathHelper;
}
org.springframework.web.accept.PathExtensionContentNegotiationStrategy
@Deprecated public void setUseJaf(boolean useJaf)
{
    setUseRegisteredExtensionsOnly(!useJaf);
}
 ServletPathExtensionContentNegotiationStrategy
 extends PathExtensionContentNegotiationStrategy
org.springframework.web.accept.ServletPathExtensionContentNegotiationStrategy
public ServletPathExtensionContentNegotiationStrategy ServletPathExtensionContentNegotiationStrategy(ServletContext context)
{
    this(context, null);
}
org.springframework.web.accept.ServletPathExtensionContentNegotiationStrategy
public ServletPathExtensionContentNegotiationStrategy ServletPathExtensionContentNegotiationStrategy(ServletContext servletContext, @Nullable Map<String, MediaType> mediaTypes)
{
    super(mediaTypes);
    Assert.notNull(servletContext, "ServletContext is required");
    this.servletContext = servletContext;
}
org.springframework.web.accept.ServletPathExtensionContentNegotiationStrategy
@Override public MediaType getMediaTypeForResource(Resource resource)
{
    MediaType mediaType = null;
    String mimeType = this.servletContext.getMimeType(resource.getFilename());
    if (StringUtils.hasText(mimeType)) {
        mediaType = MediaType.parseMediaType(mimeType);
    } 
    if (mediaType == null || MediaType.APPLICATION_OCTET_STREAM.equals(mediaType)) {
        MediaType superMediaType = super.getMediaTypeForResource(resource);
        if (superMediaType != null) {
            mediaType = superMediaType;
        } 
    } 
    return mediaType;
}
org.springframework.web.accept.ServletPathExtensionContentNegotiationStrategy
@Override @Nullable protected MediaType handleNoMatch(NativeWebRequest webRequest, String extension)
{
    MediaType mediaType = null;
    String mimeType = this.servletContext.getMimeType("file." + extension);
    if (StringUtils.hasText(mimeType)) {
        mediaType = MediaType.parseMediaType(mimeType);
    } 
    if (mediaType == null || MediaType.APPLICATION_OCTET_STREAM.equals(mediaType)) {
        MediaType superMediaType = super.handleNoMatch(webRequest, extension);
        if (superMediaType != null) {
            mediaType = superMediaType;
        } 
    } 
    return mediaType;
}
 EscapedErrors
 implements Errors
org.springframework.web.bind.EscapedErrors
public EscapedErrors EscapedErrors(Errors source)
{
    Assert.notNull(source, "Errors source must not be null");
    this.source = source;
}
org.springframework.web.bind.EscapedErrors
@Override public void addAllErrors(Errors errors)
{
    this.source.addAllErrors(errors);
}
org.springframework.web.bind.EscapedErrors
@Override public List<ObjectError> getAllErrors()
{
    return escapeObjectErrors(this.source.getAllErrors());
}
org.springframework.web.bind.EscapedErrors
@Override public int getErrorCount()
{
    return this.source.getErrorCount();
}
org.springframework.web.bind.EscapedErrors
@Override @Nullable public FieldError getFieldError()
{
    return this.source.getFieldError();
}
org.springframework.web.bind.EscapedErrors
@Override @Nullable public FieldError getFieldError(String field)
{
    return escapeObjectError(this.source.getFieldError(field));
}
org.springframework.web.bind.EscapedErrors
@Override public int getFieldErrorCount()
{
    return this.source.getFieldErrorCount();
}
org.springframework.web.bind.EscapedErrors
@Override public int getFieldErrorCount(String field)
{
    return this.source.getFieldErrorCount(field);
}
org.springframework.web.bind.EscapedErrors
@Override public List<FieldError> getFieldErrors()
{
    return this.source.getFieldErrors();
}
org.springframework.web.bind.EscapedErrors
@Override public List<FieldError> getFieldErrors(String field)
{
    return escapeObjectErrors(this.source.getFieldErrors(field));
}
org.springframework.web.bind.EscapedErrors
@Override @Nullable public Class<?> getFieldType(String field)
{
    return this.source.getFieldType(field);
}
org.springframework.web.bind.EscapedErrors
@Override @Nullable public Object getFieldValue(String field)
{
    Object value = this.source.getFieldValue(field);
    return (value instanceof String ? HtmlUtils.htmlEscape((String)value) : value);
}
org.springframework.web.bind.EscapedErrors
@Override @Nullable public ObjectError getGlobalError()
{
    return escapeObjectError(this.source.getGlobalError());
}
org.springframework.web.bind.EscapedErrors
@Override public int getGlobalErrorCount()
{
    return this.source.getGlobalErrorCount();
}
org.springframework.web.bind.EscapedErrors
@Override public List<ObjectError> getGlobalErrors()
{
    return escapeObjectErrors(this.source.getGlobalErrors());
}
org.springframework.web.bind.EscapedErrors
@Override public String getNestedPath()
{
    return this.source.getNestedPath();
}
org.springframework.web.bind.EscapedErrors
@Override public String getObjectName()
{
    return this.source.getObjectName();
}
org.springframework.web.bind.EscapedErrors
public Errors getSource()
{
    return this.source;
}
org.springframework.web.bind.EscapedErrors
@Override public boolean hasErrors()
{
    return this.source.hasErrors();
}
org.springframework.web.bind.EscapedErrors
@Override public boolean hasFieldErrors()
{
    return this.source.hasFieldErrors();
}
org.springframework.web.bind.EscapedErrors
@Override public boolean hasFieldErrors(String field)
{
    return this.source.hasFieldErrors(field);
}
org.springframework.web.bind.EscapedErrors
@Override public boolean hasGlobalErrors()
{
    return this.source.hasGlobalErrors();
}
org.springframework.web.bind.EscapedErrors
@Override public void popNestedPath()
{
    this.source.popNestedPath();
}
org.springframework.web.bind.EscapedErrors
@Override public void pushNestedPath(String subPath)
{
    this.source.pushNestedPath(subPath);
}
org.springframework.web.bind.EscapedErrors
@Override public void reject(String errorCode)
{
    this.source.reject(errorCode);
}
org.springframework.web.bind.EscapedErrors
@Override public void reject(String errorCode, String defaultMessage)
{
    this.source.reject(errorCode, defaultMessage);
}
org.springframework.web.bind.EscapedErrors
@Override public void reject(String errorCode, @Nullable Object[] errorArgs, @Nullable String defaultMessage)
{
    this.source.reject(errorCode, errorArgs, defaultMessage);
}
org.springframework.web.bind.EscapedErrors
@Override public void rejectValue(@Nullable String field, String errorCode)
{
    this.source.rejectValue(field, errorCode);
}
org.springframework.web.bind.EscapedErrors
@Override public void rejectValue(@Nullable String field, String errorCode, String defaultMessage)
{
    this.source.rejectValue(field, errorCode, defaultMessage);
}
org.springframework.web.bind.EscapedErrors
@Override public void rejectValue(@Nullable String field, String errorCode, @Nullable Object[] errorArgs, @Nullable String defaultMessage)
{
    this.source.rejectValue(field, errorCode, errorArgs, defaultMessage);
}
org.springframework.web.bind.EscapedErrors
@Override public void setNestedPath(String nestedPath)
{
    this.source.setNestedPath(nestedPath);
}
 MethodArgumentNotValidException
 extends Exception
org.springframework.web.bind.MethodArgumentNotValidException
public MethodArgumentNotValidException MethodArgumentNotValidException(MethodParameter parameter, BindingResult bindingResult)
{
    this.parameter = parameter;
    this.bindingResult = bindingResult;
}
org.springframework.web.bind.MethodArgumentNotValidException
public BindingResult getBindingResult()
{
    return this.bindingResult;
}
org.springframework.web.bind.MethodArgumentNotValidException
public MethodParameter getParameter()
{
    return this.parameter;
}
 MissingMatrixVariableException
 extends ServletRequestBindingException
org.springframework.web.bind.MissingMatrixVariableException
public MissingMatrixVariableException MissingMatrixVariableException(String variableName, MethodParameter parameter)
{
    super("");
    this.variableName = variableName;
    this.parameter = parameter;
}
org.springframework.web.bind.MissingMatrixVariableException
public final MethodParameter getParameter()
{
    return this.parameter;
}
org.springframework.web.bind.MissingMatrixVariableException
public final String getVariableName()
{
    return this.variableName;
}
 MissingPathVariableException
 extends ServletRequestBindingException
org.springframework.web.bind.MissingPathVariableException
public MissingPathVariableException MissingPathVariableException(String variableName, MethodParameter parameter)
{
    super("");
    this.variableName = variableName;
    this.parameter = parameter;
}
org.springframework.web.bind.MissingPathVariableException
public final MethodParameter getParameter()
{
    return this.parameter;
}
org.springframework.web.bind.MissingPathVariableException
public final String getVariableName()
{
    return this.variableName;
}
 MissingRequestCookieException
 extends ServletRequestBindingException
org.springframework.web.bind.MissingRequestCookieException
public MissingRequestCookieException MissingRequestCookieException(String cookieName, MethodParameter parameter)
{
    super("");
    this.cookieName = cookieName;
    this.parameter = parameter;
}
org.springframework.web.bind.MissingRequestCookieException
public final String getCookieName()
{
    return this.cookieName;
}
org.springframework.web.bind.MissingRequestCookieException
public final MethodParameter getParameter()
{
    return this.parameter;
}
 MissingRequestHeaderException
 extends ServletRequestBindingException
org.springframework.web.bind.MissingRequestHeaderException
public MissingRequestHeaderException MissingRequestHeaderException(String headerName, MethodParameter parameter)
{
    super("");
    this.headerName = headerName;
    this.parameter = parameter;
}
org.springframework.web.bind.MissingRequestHeaderException
public final String getHeaderName()
{
    return this.headerName;
}
org.springframework.web.bind.MissingRequestHeaderException
public final MethodParameter getParameter()
{
    return this.parameter;
}
 MissingServletRequestParameterException
 extends ServletRequestBindingException
org.springframework.web.bind.MissingServletRequestParameterException
public MissingServletRequestParameterException MissingServletRequestParameterException(String parameterName, String parameterType)
{
    super("");
    this.parameterName = parameterName;
    this.parameterType = parameterType;
}
org.springframework.web.bind.MissingServletRequestParameterException
@Override public String getMessage()
{
    return "Required " + this.parameterType + " parameter '" + this.parameterName + "' is not present";
}
org.springframework.web.bind.MissingServletRequestParameterException
public final String getParameterName()
{
    return this.parameterName;
}
org.springframework.web.bind.MissingServletRequestParameterException
public final String getParameterType()
{
    return this.parameterType;
}
 ServletRequestBindingException
 extends NestedServletException
org.springframework.web.bind.ServletRequestBindingException
public ServletRequestBindingException ServletRequestBindingException(String msg)
{
    super(msg);
}
org.springframework.web.bind.ServletRequestBindingException
public ServletRequestBindingException ServletRequestBindingException(String msg, Throwable cause)
{
    super(msg, cause);
}
 ServletRequestDataBinder
 extends WebDataBinder
org.springframework.web.bind.ServletRequestDataBinder
public ServletRequestDataBinder ServletRequestDataBinder(@Nullable Object target)
{
    super(target);
}
org.springframework.web.bind.ServletRequestDataBinder
public ServletRequestDataBinder ServletRequestDataBinder(@Nullable Object target, String objectName)
{
    super(target, objectName);
}
org.springframework.web.bind.ServletRequestDataBinder
protected void addBindValues(MutablePropertyValues mpvs, ServletRequest request)
{
}
 ServletRequestParameterPropertyValues
 extends MutablePropertyValues
org.springframework.web.bind.ServletRequestParameterPropertyValues
public static final String DEFAULT_PREFIX_SEPARATOR
org.springframework.web.bind.ServletRequestParameterPropertyValues
public ServletRequestParameterPropertyValues ServletRequestParameterPropertyValues(ServletRequest request)
{
    this(request, null, null);
}
org.springframework.web.bind.ServletRequestParameterPropertyValues
public ServletRequestParameterPropertyValues ServletRequestParameterPropertyValues(ServletRequest request, @Nullable String prefix)
{
    this(request, prefix, DEFAULT_PREFIX_SEPARATOR);
}
org.springframework.web.bind.ServletRequestParameterPropertyValues
public ServletRequestParameterPropertyValues ServletRequestParameterPropertyValues(ServletRequest request, @Nullable String prefix, @Nullable String prefixSeparator)
{
    super(WebUtils.getParametersStartingWith(request, (prefix != null ? prefix + prefixSeparator : null)));
}
 ServletRequestUtils
org.springframework.web.bind.ServletRequestUtils
@Nullable public static Boolean getBooleanParameter(ServletRequest request, String name)
{
    if (request.getParameter(name) == null) {
        return null;
    } 
    return (getRequiredBooleanParameter(request, name));
}
org.springframework.web.bind.ServletRequestUtils
public static boolean getBooleanParameter(ServletRequest request, String name, boolean defaultVal)
{
    if (request.getParameter(name) == null) {
        return defaultVal;
    } 
    try {
        return getRequiredBooleanParameter(request, name);
    } catch (ServletRequestBindingException ex) {
        return defaultVal;
    }
}
org.springframework.web.bind.ServletRequestUtils
public static boolean[] getBooleanParameters(ServletRequest request, String name)
{
    try {
        return getRequiredBooleanParameters(request, name);
    } catch (ServletRequestBindingException ex) {
        return new boolean[0];
    }
}
org.springframework.web.bind.ServletRequestUtils
@Nullable public static Double getDoubleParameter(ServletRequest request, String name)
{
    if (request.getParameter(name) == null) {
        return null;
    } 
    return getRequiredDoubleParameter(request, name);
}
org.springframework.web.bind.ServletRequestUtils
public static double getDoubleParameter(ServletRequest request, String name, double defaultVal)
{
    if (request.getParameter(name) == null) {
        return defaultVal;
    } 
    try {
        return getRequiredDoubleParameter(request, name);
    } catch (ServletRequestBindingException ex) {
        return defaultVal;
    }
}
org.springframework.web.bind.ServletRequestUtils
public static double[] getDoubleParameters(ServletRequest request, String name)
{
    try {
        return getRequiredDoubleParameters(request, name);
    } catch (ServletRequestBindingException ex) {
        return new double[0];
    }
}
org.springframework.web.bind.ServletRequestUtils
@Nullable public static Float getFloatParameter(ServletRequest request, String name)
{
    if (request.getParameter(name) == null) {
        return null;
    } 
    return getRequiredFloatParameter(request, name);
}
org.springframework.web.bind.ServletRequestUtils
public static float getFloatParameter(ServletRequest request, String name, float defaultVal)
{
    if (request.getParameter(name) == null) {
        return defaultVal;
    } 
    try {
        return getRequiredFloatParameter(request, name);
    } catch (ServletRequestBindingException ex) {
        return defaultVal;
    }
}
org.springframework.web.bind.ServletRequestUtils
public static float[] getFloatParameters(ServletRequest request, String name)
{
    try {
        return getRequiredFloatParameters(request, name);
    } catch (ServletRequestBindingException ex) {
        return new float[0];
    }
}
org.springframework.web.bind.ServletRequestUtils
@Nullable public static Integer getIntParameter(ServletRequest request, String name)
{
    if (request.getParameter(name) == null) {
        return null;
    } 
    return getRequiredIntParameter(request, name);
}
org.springframework.web.bind.ServletRequestUtils
public static int getIntParameter(ServletRequest request, String name, int defaultVal)
{
    if (request.getParameter(name) == null) {
        return defaultVal;
    } 
    try {
        return getRequiredIntParameter(request, name);
    } catch (ServletRequestBindingException ex) {
        return defaultVal;
    }
}
org.springframework.web.bind.ServletRequestUtils
public static int[] getIntParameters(ServletRequest request, String name)
{
    try {
        return getRequiredIntParameters(request, name);
    } catch (ServletRequestBindingException ex) {
        return new int[0];
    }
}
org.springframework.web.bind.ServletRequestUtils
@Nullable public static Long getLongParameter(ServletRequest request, String name)
{
    if (request.getParameter(name) == null) {
        return null;
    } 
    return getRequiredLongParameter(request, name);
}
org.springframework.web.bind.ServletRequestUtils
public static long getLongParameter(ServletRequest request, String name, long defaultVal)
{
    if (request.getParameter(name) == null) {
        return defaultVal;
    } 
    try {
        return getRequiredLongParameter(request, name);
    } catch (ServletRequestBindingException ex) {
        return defaultVal;
    }
}
org.springframework.web.bind.ServletRequestUtils
public static long[] getLongParameters(ServletRequest request, String name)
{
    try {
        return getRequiredLongParameters(request, name);
    } catch (ServletRequestBindingException ex) {
        return new long[0];
    }
}
org.springframework.web.bind.ServletRequestUtils
public static boolean getRequiredBooleanParameter(ServletRequest request, String name)
{
    return BOOLEAN_PARSER.parseBoolean(name, request.getParameter(name));
}
org.springframework.web.bind.ServletRequestUtils
public static boolean[] getRequiredBooleanParameters(ServletRequest request, String name)
{
    return BOOLEAN_PARSER.parseBooleans(name, request.getParameterValues(name));
}
org.springframework.web.bind.ServletRequestUtils
public static double getRequiredDoubleParameter(ServletRequest request, String name)
{
    return DOUBLE_PARSER.parseDouble(name, request.getParameter(name));
}
org.springframework.web.bind.ServletRequestUtils
public static double[] getRequiredDoubleParameters(ServletRequest request, String name)
{
    return DOUBLE_PARSER.parseDoubles(name, request.getParameterValues(name));
}
org.springframework.web.bind.ServletRequestUtils
public static float getRequiredFloatParameter(ServletRequest request, String name)
{
    return FLOAT_PARSER.parseFloat(name, request.getParameter(name));
}
org.springframework.web.bind.ServletRequestUtils
public static float[] getRequiredFloatParameters(ServletRequest request, String name)
{
    return FLOAT_PARSER.parseFloats(name, request.getParameterValues(name));
}
org.springframework.web.bind.ServletRequestUtils
public static int getRequiredIntParameter(ServletRequest request, String name)
{
    return INT_PARSER.parseInt(name, request.getParameter(name));
}
org.springframework.web.bind.ServletRequestUtils
public static int[] getRequiredIntParameters(ServletRequest request, String name)
{
    return INT_PARSER.parseInts(name, request.getParameterValues(name));
}
org.springframework.web.bind.ServletRequestUtils
public static long getRequiredLongParameter(ServletRequest request, String name)
{
    return LONG_PARSER.parseLong(name, request.getParameter(name));
}
org.springframework.web.bind.ServletRequestUtils
public static long[] getRequiredLongParameters(ServletRequest request, String name)
{
    return LONG_PARSER.parseLongs(name, request.getParameterValues(name));
}
org.springframework.web.bind.ServletRequestUtils
public static String getRequiredStringParameter(ServletRequest request, String name)
{
    return STRING_PARSER.validateRequiredString(name, request.getParameter(name));
}
org.springframework.web.bind.ServletRequestUtils
public static String[] getRequiredStringParameters(ServletRequest request, String name)
{
    return STRING_PARSER.validateRequiredStrings(name, request.getParameterValues(name));
}
org.springframework.web.bind.ServletRequestUtils
@Nullable public static String getStringParameter(ServletRequest request, String name)
{
    if (request.getParameter(name) == null) {
        return null;
    } 
    return getRequiredStringParameter(request, name);
}
org.springframework.web.bind.ServletRequestUtils
public static String getStringParameter(ServletRequest request, String name, String defaultVal)
{
    String val = request.getParameter(name);
    return (val != null ? val : defaultVal);
}
org.springframework.web.bind.ServletRequestUtils
public static String[] getStringParameters(ServletRequest request, String name)
{
    try {
        return getRequiredStringParameters(request, name);
    } catch (ServletRequestBindingException ex) {
        return new String[0];
    }
}
 UnsatisfiedServletRequestParameterException
 extends ServletRequestBindingException
org.springframework.web.bind.UnsatisfiedServletRequestParameterException
public UnsatisfiedServletRequestParameterException UnsatisfiedServletRequestParameterException(String[] paramConditions, Map<String, String[]> actualParams)
{
    super("");
    this.paramConditions = Arrays.<String[]>asList(paramConditions);
    this.actualParams = actualParams;
}
org.springframework.web.bind.UnsatisfiedServletRequestParameterException
public UnsatisfiedServletRequestParameterException UnsatisfiedServletRequestParameterException(List<String[]> paramConditions, Map<String, String[]> actualParams)
{
    super("");
    Assert.notEmpty(paramConditions, "Parameter conditions must not be empty");
    this.paramConditions = paramConditions;
    this.actualParams = actualParams;
}
org.springframework.web.bind.UnsatisfiedServletRequestParameterException
public final Map<String, String[]> getActualParams()
{
    return this.actualParams;
}
org.springframework.web.bind.UnsatisfiedServletRequestParameterException
@Override public String getMessage()
{
    StringBuilder sb = new StringBuilder("Parameter conditions ");
    int i = 0;
    for (String[] conditions: this.paramConditions) {
        if (i > 0) {
            sb.append(" OR ");
        } 
        sb.append("\"");
        sb.append(StringUtils.arrayToDelimitedString(conditions, ", "));
        sb.append("\"");
        i++;
    }
    sb.append(" not met for actual request parameters: ");
    sb.append(requestParameterMapToString(this.actualParams));
    return sb.toString();
}
org.springframework.web.bind.UnsatisfiedServletRequestParameterException
public final List<String[]> getParamConditionGroups()
{
    return this.paramConditions;
}
org.springframework.web.bind.UnsatisfiedServletRequestParameterException
public final String[] getParamConditions()
{
    return this.paramConditions.get(0);
}
 WebDataBinder
 extends DataBinder
org.springframework.web.bind.WebDataBinder
public static final String DEFAULT_FIELD_DEFAULT_PREFIX
org.springframework.web.bind.WebDataBinder
public static final String DEFAULT_FIELD_MARKER_PREFIX
org.springframework.web.bind.WebDataBinder
public WebDataBinder WebDataBinder(@Nullable Object target)
{
    super(target);
}
org.springframework.web.bind.WebDataBinder
public WebDataBinder WebDataBinder(@Nullable Object target, String objectName)
{
    super(target, objectName);
}
org.springframework.web.bind.WebDataBinder
protected void bindMultipart(Map<String, List<MultipartFile>> multipartFiles, MutablePropertyValues mpvs)
{
    multipartFiles.forEach((key, values) -> {
        if (values.size() == 1) {
            MultipartFile value = values.get(0);
            if (isBindEmptyMultipartFiles() || !value.isEmpty()) {
                mpvs.add(key, value);
            } 
        } else {
            mpvs.add(key, values);
        }
    });
}
org.springframework.web.bind.WebDataBinder
@Override protected void doBind(MutablePropertyValues mpvs)
{
    checkFieldDefaults(mpvs);
    checkFieldMarkers(mpvs);
    super.doBind(mpvs);
}
org.springframework.web.bind.WebDataBinder
@Nullable protected Object getEmptyValue(String field, @Nullable Class<?> fieldType)
{
    return (fieldType != null ? getEmptyValue(fieldType) : null);
}
org.springframework.web.bind.WebDataBinder
@Nullable public Object getEmptyValue(Class<?> fieldType)
{
    try {
        if (boolean.class == fieldType || Boolean.class == fieldType) {
            return Boolean.FALSE;
        } else if (fieldType.isArray()) {
            return Array.newInstance(fieldType.getComponentType(), 0);
        } else if (Collection.class.isAssignableFrom(fieldType)) {
            return CollectionFactory.createCollection(fieldType, 0);
        } else if (Map.class.isAssignableFrom(fieldType)) {
            return CollectionFactory.createMap(fieldType, 0);
        } 
    } catch (IllegalArgumentException ex) {
        if (logger.isDebugEnabled()) {
            logger.debug("Failed to create default value - falling back to null: " + ex.getMessage());
        } 
    }
    return null;
}
org.springframework.web.bind.WebDataBinder
@Nullable public String getFieldDefaultPrefix()
{
    return this.fieldDefaultPrefix;
}
org.springframework.web.bind.WebDataBinder
@Nullable public String getFieldMarkerPrefix()
{
    return this.fieldMarkerPrefix;
}
org.springframework.web.bind.WebDataBinder
public boolean isBindEmptyMultipartFiles()
{
    return this.bindEmptyMultipartFiles;
}
org.springframework.web.bind.WebDataBinder
public void setBindEmptyMultipartFiles(boolean bindEmptyMultipartFiles)
{
    this.bindEmptyMultipartFiles = bindEmptyMultipartFiles;
}
org.springframework.web.bind.WebDataBinder
public void setFieldDefaultPrefix(@Nullable String fieldDefaultPrefix)
{
    this.fieldDefaultPrefix = fieldDefaultPrefix;
}
org.springframework.web.bind.WebDataBinder
public void setFieldMarkerPrefix(@Nullable String fieldMarkerPrefix)
{
    this.fieldMarkerPrefix = fieldMarkerPrefix;
}
@ControllerAdvice
org.springframework.web.bind.annotation.ControllerAdvice
@AliasFor("basePackages") private String[] value()
org.springframework.web.bind.annotation.ControllerAdvice
@AliasFor("value") private String[] basePackages()
org.springframework.web.bind.annotation.ControllerAdvice
private Class<?>[] basePackageClasses()
org.springframework.web.bind.annotation.ControllerAdvice
private Class<?>[] assignableTypes()
org.springframework.web.bind.annotation.ControllerAdvice
private Class<?>[] annotations()
@CookieValue
파라미터에 표시
org.springframework.web.bind.annotation.CookieValue
@AliasFor("name") private String value()
org.springframework.web.bind.annotation.CookieValue
@AliasFor("value") private String name()
org.springframework.web.bind.annotation.CookieValue
private boolean required()
org.springframework.web.bind.annotation.CookieValue
private String defaultValue()
@CrossOrigin
org.springframework.web.bind.annotation.CrossOrigin
@Deprecated private String[] DEFAULT_ORIGINS
org.springframework.web.bind.annotation.CrossOrigin
@Deprecated private String[] DEFAULT_ALLOWED_HEADERS
org.springframework.web.bind.annotation.CrossOrigin
@Deprecated private boolean DEFAULT_ALLOW_CREDENTIALS
org.springframework.web.bind.annotation.CrossOrigin
@Deprecated private long DEFAULT_MAX_AGE
org.springframework.web.bind.annotation.CrossOrigin
@AliasFor("origins") private String[] value()
org.springframework.web.bind.annotation.CrossOrigin
@AliasFor("value") private String[] origins()
org.springframework.web.bind.annotation.CrossOrigin
private String[] allowedHeaders()
org.springframework.web.bind.annotation.CrossOrigin
private String[] exposedHeaders()
org.springframework.web.bind.annotation.CrossOrigin
private RequestMethod[] methods()
org.springframework.web.bind.annotation.CrossOrigin
private String allowCredentials()
org.springframework.web.bind.annotation.CrossOrigin
private long maxAge()
@DeleteMapping
함수에 표시
org.springframework.web.bind.annotation.DeleteMapping
@AliasFor(annotation=RequestMapping.class) private String name()
org.springframework.web.bind.annotation.DeleteMapping
@AliasFor(annotation=RequestMapping.class) private String[] value()
org.springframework.web.bind.annotation.DeleteMapping
@AliasFor(annotation=RequestMapping.class) private String[] path()
org.springframework.web.bind.annotation.DeleteMapping
@AliasFor(annotation=RequestMapping.class) private String[] params()
org.springframework.web.bind.annotation.DeleteMapping
@AliasFor(annotation=RequestMapping.class) private String[] headers()
org.springframework.web.bind.annotation.DeleteMapping
@AliasFor(annotation=RequestMapping.class) private String[] consumes()
org.springframework.web.bind.annotation.DeleteMapping
@AliasFor(annotation=RequestMapping.class) private String[] produces()
@ExceptionHandler
함수에 표시
org.springframework.web.bind.annotation.ExceptionHandler
private Class<?>[] value()
@GetMapping
함수에 표시
org.springframework.web.bind.annotation.GetMapping
@AliasFor(annotation=RequestMapping.class) private String name()
org.springframework.web.bind.annotation.GetMapping
@AliasFor(annotation=RequestMapping.class) private String[] value()
org.springframework.web.bind.annotation.GetMapping
@AliasFor(annotation=RequestMapping.class) private String[] path()
org.springframework.web.bind.annotation.GetMapping
@AliasFor(annotation=RequestMapping.class) private String[] params()
org.springframework.web.bind.annotation.GetMapping
@AliasFor(annotation=RequestMapping.class) private String[] headers()
org.springframework.web.bind.annotation.GetMapping
@AliasFor(annotation=RequestMapping.class) private String[] consumes()
org.springframework.web.bind.annotation.GetMapping
@AliasFor(annotation=RequestMapping.class) private String[] produces()
@InitBinder
org.springframework.web.bind.annotation.InitBinder
private String[] value()
@Mapping
@MatrixVariable
파라미터에 표시
org.springframework.web.bind.annotation.MatrixVariable
@AliasFor("name") private String value()
org.springframework.web.bind.annotation.MatrixVariable
@AliasFor("value") private String name()
org.springframework.web.bind.annotation.MatrixVariable
private String pathVar()
org.springframework.web.bind.annotation.MatrixVariable
private boolean required()
org.springframework.web.bind.annotation.MatrixVariable
private String defaultValue()
@ModelAttribute
org.springframework.web.bind.annotation.ModelAttribute
@AliasFor("name") private String value()
org.springframework.web.bind.annotation.ModelAttribute
@AliasFor("value") private String name()
org.springframework.web.bind.annotation.ModelAttribute
private boolean binding()
@PatchMapping
함수에 표시
org.springframework.web.bind.annotation.PatchMapping
@AliasFor(annotation=RequestMapping.class) private String name()
org.springframework.web.bind.annotation.PatchMapping
@AliasFor(annotation=RequestMapping.class) private String[] value()
org.springframework.web.bind.annotation.PatchMapping
@AliasFor(annotation=RequestMapping.class) private String[] path()
org.springframework.web.bind.annotation.PatchMapping
@AliasFor(annotation=RequestMapping.class) private String[] params()
org.springframework.web.bind.annotation.PatchMapping
@AliasFor(annotation=RequestMapping.class) private String[] headers()
org.springframework.web.bind.annotation.PatchMapping
@AliasFor(annotation=RequestMapping.class) private String[] consumes()
org.springframework.web.bind.annotation.PatchMapping
@AliasFor(annotation=RequestMapping.class) private String[] produces()
@PathVariable
파라미터에 표시
org.springframework.web.bind.annotation.PathVariable
@AliasFor("name") private String value()
org.springframework.web.bind.annotation.PathVariable
@AliasFor("value") private String name()
org.springframework.web.bind.annotation.PathVariable
private boolean required()
@PostMapping
함수에 표시
org.springframework.web.bind.annotation.PostMapping
@AliasFor(annotation=RequestMapping.class) private String name()
org.springframework.web.bind.annotation.PostMapping
@AliasFor(annotation=RequestMapping.class) private String[] value()
org.springframework.web.bind.annotation.PostMapping
@AliasFor(annotation=RequestMapping.class) private String[] path()
org.springframework.web.bind.annotation.PostMapping
@AliasFor(annotation=RequestMapping.class) private String[] params()
org.springframework.web.bind.annotation.PostMapping
@AliasFor(annotation=RequestMapping.class) private String[] headers()
org.springframework.web.bind.annotation.PostMapping
@AliasFor(annotation=RequestMapping.class) private String[] consumes()
org.springframework.web.bind.annotation.PostMapping
@AliasFor(annotation=RequestMapping.class) private String[] produces()
@PutMapping
함수에 표시
org.springframework.web.bind.annotation.PutMapping
@AliasFor(annotation=RequestMapping.class) private String name()
org.springframework.web.bind.annotation.PutMapping
@AliasFor(annotation=RequestMapping.class) private String[] value()
org.springframework.web.bind.annotation.PutMapping
@AliasFor(annotation=RequestMapping.class) private String[] path()
org.springframework.web.bind.annotation.PutMapping
@AliasFor(annotation=RequestMapping.class) private String[] params()
org.springframework.web.bind.annotation.PutMapping
@AliasFor(annotation=RequestMapping.class) private String[] headers()
org.springframework.web.bind.annotation.PutMapping
@AliasFor(annotation=RequestMapping.class) private String[] consumes()
org.springframework.web.bind.annotation.PutMapping
@AliasFor(annotation=RequestMapping.class) private String[] produces()
@RequestAttribute
파라미터에 표시
org.springframework.web.bind.annotation.RequestAttribute
@AliasFor("name") private String value()
org.springframework.web.bind.annotation.RequestAttribute
@AliasFor("value") private String name()
org.springframework.web.bind.annotation.RequestAttribute
private boolean required()
@RequestBody
파라미터에 표시
org.springframework.web.bind.annotation.RequestBody
private boolean required()
@RequestHeader
파라미터에 표시
org.springframework.web.bind.annotation.RequestHeader
@AliasFor("name") private String value()
org.springframework.web.bind.annotation.RequestHeader
@AliasFor("value") private String name()
org.springframework.web.bind.annotation.RequestHeader
private boolean required()
org.springframework.web.bind.annotation.RequestHeader
private String defaultValue()
@RequestMapping
org.springframework.web.bind.annotation.RequestMapping
private String name()
org.springframework.web.bind.annotation.RequestMapping
@AliasFor("path") private String[] value()
org.springframework.web.bind.annotation.RequestMapping
@AliasFor("value") private String[] path()
org.springframework.web.bind.annotation.RequestMapping
private RequestMethod[] method()
org.springframework.web.bind.annotation.RequestMapping
private String[] params()
org.springframework.web.bind.annotation.RequestMapping
private String[] headers()
org.springframework.web.bind.annotation.RequestMapping
private String[] consumes()
org.springframework.web.bind.annotation.RequestMapping
private String[] produces()
RequestMethod
enum values
  • GET
  • HEAD
  • POST
  • PUT
  • PATCH
  • DELETE
  • OPTIONS
  • TRACE
@RequestParam
파라미터에 표시
org.springframework.web.bind.annotation.RequestParam
@AliasFor("name") private String value()
org.springframework.web.bind.annotation.RequestParam
@AliasFor("value") private String name()
org.springframework.web.bind.annotation.RequestParam
private boolean required()
org.springframework.web.bind.annotation.RequestParam
private String defaultValue()
@RequestPart
파라미터에 표시
org.springframework.web.bind.annotation.RequestPart
@AliasFor("name") private String value()
org.springframework.web.bind.annotation.RequestPart
@AliasFor("value") private String name()
org.springframework.web.bind.annotation.RequestPart
private boolean required()
@ResponseBody
@ResponseStatus
org.springframework.web.bind.annotation.ResponseStatus
@AliasFor("code") private HttpStatus value()
org.springframework.web.bind.annotation.ResponseStatus
@AliasFor("value") private HttpStatus code()
org.springframework.web.bind.annotation.ResponseStatus
private String reason()
@RestController
org.springframework.web.bind.annotation.RestController
@AliasFor(annotation=Controller.class) private String value()
@RestControllerAdvice
org.springframework.web.bind.annotation.RestControllerAdvice
@AliasFor(annotation=ControllerAdvice.class) private String[] value()
org.springframework.web.bind.annotation.RestControllerAdvice
@AliasFor(annotation=ControllerAdvice.class) private String[] basePackages()
org.springframework.web.bind.annotation.RestControllerAdvice
@AliasFor(annotation=ControllerAdvice.class) private Class<?>[] basePackageClasses()
org.springframework.web.bind.annotation.RestControllerAdvice
@AliasFor(annotation=ControllerAdvice.class) private Class<?>[] assignableTypes()
org.springframework.web.bind.annotation.RestControllerAdvice
@AliasFor(annotation=ControllerAdvice.class) private Class<?>[] annotations()
@SessionAttribute
파라미터에 표시
org.springframework.web.bind.annotation.SessionAttribute
@AliasFor("name") private String value()
org.springframework.web.bind.annotation.SessionAttribute
@AliasFor("value") private String name()
org.springframework.web.bind.annotation.SessionAttribute
private boolean required()
@SessionAttributes
org.springframework.web.bind.annotation.SessionAttributes
@AliasFor("names") private String[] value()
org.springframework.web.bind.annotation.SessionAttributes
@AliasFor("value") private String[] names()
org.springframework.web.bind.annotation.SessionAttributes
private Class<?>[] types()
 ValueConstants
 ConfigurableWebBindingInitializer
 implements WebBindingInitializer
org.springframework.web.bind.support.ConfigurableWebBindingInitializer
@Nullable public final BindingErrorProcessor getBindingErrorProcessor()
{
    return this.bindingErrorProcessor;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer
@Nullable public final ConversionService getConversionService()
{
    return this.conversionService;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer
@Nullable public final MessageCodesResolver getMessageCodesResolver()
{
    return this.messageCodesResolver;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer
@Nullable public final PropertyEditorRegistrar[] getPropertyEditorRegistrars()
{
    return this.propertyEditorRegistrars;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer
@Nullable public final Validator getValidator()
{
    return this.validator;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer
@Override public void initBinder(WebDataBinder binder)
{
    binder.setAutoGrowNestedPaths(this.autoGrowNestedPaths);
    if (this.directFieldAccess) {
        binder.initDirectFieldAccess();
    } 
    if (this.messageCodesResolver != null) {
        binder.setMessageCodesResolver(this.messageCodesResolver);
    } 
    if (this.bindingErrorProcessor != null) {
        binder.setBindingErrorProcessor(this.bindingErrorProcessor);
    } 
    if (this.validator != null && binder.getTarget() != null && this.validator.supports(binder.getTarget().getClass())) {
        binder.setValidator(this.validator);
    } 
    if (this.conversionService != null) {
        binder.setConversionService(this.conversionService);
    } 
    if (this.propertyEditorRegistrars != null) {
        for (PropertyEditorRegistrar propertyEditorRegistrar: this.propertyEditorRegistrars) {
            propertyEditorRegistrar.registerCustomEditors(binder);
        }
    } 
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer
public boolean isAutoGrowNestedPaths()
{
    return this.autoGrowNestedPaths;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer
public boolean isDirectFieldAccess()
{
    return this.directFieldAccess;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer
public void setAutoGrowNestedPaths(boolean autoGrowNestedPaths)
{
    this.autoGrowNestedPaths = autoGrowNestedPaths;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer
public final void setBindingErrorProcessor(@Nullable BindingErrorProcessor bindingErrorProcessor)
{
    this.bindingErrorProcessor = bindingErrorProcessor;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer
public final void setConversionService(@Nullable ConversionService conversionService)
{
    this.conversionService = conversionService;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer
public final void setDirectFieldAccess(boolean directFieldAccess)
{
    this.directFieldAccess = directFieldAccess;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer
public final void setMessageCodesResolver(@Nullable MessageCodesResolver messageCodesResolver)
{
    this.messageCodesResolver = messageCodesResolver;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer
public final void setPropertyEditorRegistrar(PropertyEditorRegistrar propertyEditorRegistrar)
{
    this.propertyEditorRegistrars = new PropertyEditorRegistrar[]{propertyEditorRegistrar};
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer
public final void setPropertyEditorRegistrars(@Nullable PropertyEditorRegistrar[] propertyEditorRegistrars)
{
    this.propertyEditorRegistrars = propertyEditorRegistrars;
}
org.springframework.web.bind.support.ConfigurableWebBindingInitializer
public final void setValidator(@Nullable Validator validator)
{
    this.validator = validator;
}
 DefaultDataBinderFactory
 implements WebDataBinderFactory
org.springframework.web.bind.support.DefaultDataBinderFactory
public DefaultDataBinderFactory DefaultDataBinderFactory(@Nullable WebBindingInitializer initializer)
{
    this.initializer = initializer;
}
org.springframework.web.bind.support.DefaultDataBinderFactory
@Override @SuppressWarnings("deprecation") public final WebDataBinder createBinder(NativeWebRequest webRequest, @Nullable Object target, String objectName)
{
    WebDataBinder dataBinder = createBinderInstance(target, objectName, webRequest);
    if (this.initializer != null) {
        this.initializer.initBinder(dataBinder, webRequest);
    } 
    initBinder(dataBinder, webRequest);
    return dataBinder;
}
org.springframework.web.bind.support.DefaultDataBinderFactory
protected WebDataBinder createBinderInstance(@Nullable Object target, String objectName, NativeWebRequest webRequest)
{
    return new WebRequestDataBinder(target, objectName);
}
org.springframework.web.bind.support.DefaultDataBinderFactory
protected void initBinder(WebDataBinder dataBinder, NativeWebRequest webRequest)
{
}
 DefaultSessionAttributeStore
 implements SessionAttributeStore
org.springframework.web.bind.support.DefaultSessionAttributeStore
protected String getAttributeNameInSession(WebRequest request, String attributeName)
{
    return this.attributeNamePrefix + attributeName;
}
org.springframework.web.bind.support.DefaultSessionAttributeStore
public void setAttributeNamePrefix(@Nullable String attributeNamePrefix)
{
    this.attributeNamePrefix = (attributeNamePrefix != null ? attributeNamePrefix : "");
}
 SessionAttributeStore
 SessionStatus
 SimpleSessionStatus
 implements SessionStatus
org.springframework.web.bind.support.SimpleSessionStatus
@Override public boolean isComplete()
{
    return this.complete;
}
org.springframework.web.bind.support.SimpleSessionStatus
@Override public void setComplete()
{
    this.complete = true;
}
 SpringWebConstraintValidatorFactory
 implements ConstraintValidatorFactory
org.springframework.web.bind.support.SpringWebConstraintValidatorFactory
<T>@Override public T getInstance(Class<T> key)
{
    return getWebApplicationContext().getAutowireCapableBeanFactory().createBean(key);
}
org.springframework.web.bind.support.SpringWebConstraintValidatorFactory
@Override public void releaseInstance(ConstraintValidator<?, ?> instance)
{
    getWebApplicationContext().getAutowireCapableBeanFactory().destroyBean(instance);
}
 WebArgumentResolver
 WebBindingInitializer
 WebDataBinderFactory
 WebExchangeBindException
 extends ServerWebInputException implements BindingResult
org.springframework.web.bind.support.WebExchangeBindException
public WebExchangeBindException WebExchangeBindException(MethodParameter parameter, BindingResult bindingResult)
{
    super("Validation failure", parameter);
    this.bindingResult = bindingResult;
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public void addAllErrors(Errors errors)
{
    this.bindingResult.addAllErrors(errors);
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public void addError(ObjectError error)
{
    this.bindingResult.addError(error);
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public boolean equals(@Nullable Object other)
{
    return (this == other || this.bindingResult.equals(other));
}
org.springframework.web.bind.support.WebExchangeBindException
@Override @SuppressWarnings("rawtypes") @Nullable public PropertyEditor findEditor(@Nullable String field, @Nullable Class valueType)
{
    return this.bindingResult.findEditor(field, valueType);
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public List<ObjectError> getAllErrors()
{
    return this.bindingResult.getAllErrors();
}
org.springframework.web.bind.support.WebExchangeBindException
public final BindingResult getBindingResult()
{
    return this.bindingResult;
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public int getErrorCount()
{
    return this.bindingResult.getErrorCount();
}
org.springframework.web.bind.support.WebExchangeBindException
@Override @Nullable public FieldError getFieldError()
{
    return this.bindingResult.getFieldError();
}
org.springframework.web.bind.support.WebExchangeBindException
@Override @Nullable public FieldError getFieldError(String field)
{
    return this.bindingResult.getFieldError(field);
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public int getFieldErrorCount()
{
    return this.bindingResult.getFieldErrorCount();
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public int getFieldErrorCount(String field)
{
    return this.bindingResult.getFieldErrorCount(field);
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public List<FieldError> getFieldErrors()
{
    return this.bindingResult.getFieldErrors();
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public List<FieldError> getFieldErrors(String field)
{
    return this.bindingResult.getFieldErrors(field);
}
org.springframework.web.bind.support.WebExchangeBindException
@Override @Nullable public Class<?> getFieldType(String field)
{
    return this.bindingResult.getFieldType(field);
}
org.springframework.web.bind.support.WebExchangeBindException
@Override @Nullable public Object getFieldValue(String field)
{
    return this.bindingResult.getFieldValue(field);
}
org.springframework.web.bind.support.WebExchangeBindException
@Override @Nullable public ObjectError getGlobalError()
{
    return this.bindingResult.getGlobalError();
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public int getGlobalErrorCount()
{
    return this.bindingResult.getGlobalErrorCount();
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public List<ObjectError> getGlobalErrors()
{
    return this.bindingResult.getGlobalErrors();
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public Map<String, Object> getModel()
{
    return this.bindingResult.getModel();
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public String getNestedPath()
{
    return this.bindingResult.getNestedPath();
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public String getObjectName()
{
    return this.bindingResult.getObjectName();
}
org.springframework.web.bind.support.WebExchangeBindException
@Override @Nullable public PropertyEditorRegistry getPropertyEditorRegistry()
{
    return this.bindingResult.getPropertyEditorRegistry();
}
org.springframework.web.bind.support.WebExchangeBindException
@Override @Nullable public Object getRawFieldValue(String field)
{
    return this.bindingResult.getRawFieldValue(field);
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public String[] getSuppressedFields()
{
    return this.bindingResult.getSuppressedFields();
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public Object getTarget()
{
    return this.bindingResult.getTarget();
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public boolean hasErrors()
{
    return this.bindingResult.hasErrors();
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public boolean hasFieldErrors()
{
    return this.bindingResult.hasFieldErrors();
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public boolean hasFieldErrors(String field)
{
    return this.bindingResult.hasFieldErrors(field);
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public boolean hasGlobalErrors()
{
    return this.bindingResult.hasGlobalErrors();
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public int hashCode()
{
    return this.bindingResult.hashCode();
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public void popNestedPath()
{
    this.bindingResult.popNestedPath();
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public void pushNestedPath(String subPath)
{
    this.bindingResult.pushNestedPath(subPath);
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public void recordFieldValue(String field, Class<?> type, @Nullable Object value)
{
    this.bindingResult.recordFieldValue(field, type, value);
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public void recordSuppressedField(String field)
{
    this.bindingResult.recordSuppressedField(field);
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public void reject(String errorCode)
{
    this.bindingResult.reject(errorCode);
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public void reject(String errorCode, String defaultMessage)
{
    this.bindingResult.reject(errorCode, defaultMessage);
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public void reject(String errorCode, @Nullable Object[] errorArgs, @Nullable String defaultMessage)
{
    this.bindingResult.reject(errorCode, errorArgs, defaultMessage);
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public void rejectValue(@Nullable String field, String errorCode)
{
    this.bindingResult.rejectValue(field, errorCode);
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public void rejectValue(@Nullable String field, String errorCode, String defaultMessage)
{
    this.bindingResult.rejectValue(field, errorCode, defaultMessage);
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public void rejectValue(@Nullable String field, String errorCode, @Nullable Object[] errorArgs, @Nullable String defaultMessage)
{
    this.bindingResult.rejectValue(field, errorCode, errorArgs, defaultMessage);
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public String[] resolveMessageCodes(String errorCode)
{
    return this.bindingResult.resolveMessageCodes(errorCode);
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public String[] resolveMessageCodes(String errorCode, String field)
{
    return this.bindingResult.resolveMessageCodes(errorCode, field);
}
org.springframework.web.bind.support.WebExchangeBindException
@Override public void setNestedPath(String nestedPath)
{
    this.bindingResult.setNestedPath(nestedPath);
}
 WebExchangeDataBinder
 extends WebDataBinder
org.springframework.web.bind.support.WebExchangeDataBinder
public WebExchangeDataBinder WebExchangeDataBinder(@Nullable Object target)
{
    super(target);
}
org.springframework.web.bind.support.WebExchangeDataBinder
public WebExchangeDataBinder WebExchangeDataBinder(@Nullable Object target, String objectName)
{
    super(target, objectName);
}
org.springframework.web.bind.support.WebExchangeDataBinder
public Mono<Void> bind(ServerWebExchange exchange)
{
    return getValuesToBind(exchange).doOnNext(values -> doBind(new MutablePropertyValues(values))).then();
}
org.springframework.web.bind.support.WebExchangeDataBinder
protected Mono<Map<String, Object>> getValuesToBind(ServerWebExchange exchange)
{
    return extractValuesToBind(exchange);
}
 WebRequestDataBinder
 extends WebDataBinder
org.springframework.web.bind.support.WebRequestDataBinder
public WebRequestDataBinder WebRequestDataBinder(@Nullable Object target)
{
    super(target);
}
org.springframework.web.bind.support.WebRequestDataBinder
public WebRequestDataBinder WebRequestDataBinder(@Nullable Object target, String objectName)
{
    super(target, objectName);
}
org.springframework.web.bind.support.WebRequestDataBinder
public void closeNoCatch()
{
    if (getBindingResult().hasErrors()) {
        throw new BindException(getBindingResult());
    } 
}
 AsyncRequestCallback
 AsyncRestOperations
 AsyncRestTemplate
 extends org.springframework.http.client.support.InterceptingAsyncHttpAccessor implements AsyncRestOperations
org.springframework.web.client.AsyncRestTemplate
public AsyncRestTemplate AsyncRestTemplate()
{
    this(new SimpleAsyncTaskExecutor());
}
org.springframework.web.client.AsyncRestTemplate
public AsyncRestTemplate AsyncRestTemplate(org.springframework.http.client.AsyncClientHttpRequestFactory asyncRequestFactory)
{
    this(asyncRequestFactory, (ClientHttpRequestFactory)asyncRequestFactory);
}
org.springframework.web.client.AsyncRestTemplate
public AsyncRestTemplate AsyncRestTemplate(org.springframework.http.client.AsyncClientHttpRequestFactory asyncRequestFactory, ClientHttpRequestFactory syncRequestFactory)
{
    this(asyncRequestFactory, new RestTemplate(syncRequestFactory));
}
org.springframework.web.client.AsyncRestTemplate
public AsyncRestTemplate AsyncRestTemplate(org.springframework.http.client.AsyncClientHttpRequestFactory requestFactory, RestTemplate restTemplate)
{
    Assert.notNull(restTemplate, "RestTemplate must not be null");
    this.syncTemplate = restTemplate;
    setAsyncRequestFactory(requestFactory);
}
org.springframework.web.client.AsyncRestTemplate
<T>protected AsyncRequestCallback acceptHeaderRequestCallback(Class<T> responseType)
{
    return new AsyncRequestCallbackAdapter(this.syncTemplate.acceptHeaderRequestCallback(responseType));
}
org.springframework.web.client.AsyncRestTemplate
@Override public ListenableFuture<?> delete(String url, Object... uriVariables)
{
    return execute(url, HttpMethod.DELETE, null, null, uriVariables);
}
org.springframework.web.client.AsyncRestTemplate
@Override public ListenableFuture<?> delete(String url, Map<String, ?> uriVariables)
{
    return execute(url, HttpMethod.DELETE, null, null, uriVariables);
}
org.springframework.web.client.AsyncRestTemplate
@Override public ListenableFuture<?> delete(URI url)
{
    return execute(url, HttpMethod.DELETE, null, null);
}
org.springframework.web.client.AsyncRestTemplate
<T>protected ListenableFuture<T> doExecute(URI url, HttpMethod method, @Nullable AsyncRequestCallback requestCallback, @Nullable ResponseExtractor<T> responseExtractor)
{
    Assert.notNull(url, "'url' must not be null");
    Assert.notNull(method, "'method' must not be null");
    try {
        org.springframework.http.client.AsyncClientHttpRequest request = createAsyncRequest(url, method);
        if (requestCallback != null) {
            requestCallback.doWithRequest(request);
        } 
        ListenableFuture<ClientHttpResponse> responseFuture = request.executeAsync();
        return new ResponseExtractorFuture<>(method, url, responseFuture, responseExtractor);
    } catch (IOException ex) {
        throw new ResourceAccessException("I/O error on " + method.name() + " request for \"" + url + "\":" + ex.getMessage(), ex);
    }
}
org.springframework.web.client.AsyncRestTemplate
<T>@Override public ListenableFuture<ResponseEntity<T>> exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables)
{
    AsyncRequestCallback requestCallback = httpEntityCallback(requestEntity, responseType);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
    return execute(url, method, requestCallback, responseExtractor, uriVariables);
}
org.springframework.web.client.AsyncRestTemplate
<T>@Override public ListenableFuture<ResponseEntity<T>> exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables)
{
    AsyncRequestCallback requestCallback = httpEntityCallback(requestEntity, responseType);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
    return execute(url, method, requestCallback, responseExtractor, uriVariables);
}
org.springframework.web.client.AsyncRestTemplate
<T>@Override public ListenableFuture<ResponseEntity<T>> exchange(URI url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, Class<T> responseType)
{
    AsyncRequestCallback requestCallback = httpEntityCallback(requestEntity, responseType);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
    return execute(url, method, requestCallback, responseExtractor);
}
org.springframework.web.client.AsyncRestTemplate
<T>@Override public ListenableFuture<ResponseEntity<T>> exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType, Object... uriVariables)
{
    Type type = responseType.getType();
    AsyncRequestCallback requestCallback = httpEntityCallback(requestEntity, type);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(type);
    return execute(url, method, requestCallback, responseExtractor, uriVariables);
}
org.springframework.web.client.AsyncRestTemplate
<T>@Override public ListenableFuture<ResponseEntity<T>> exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables)
{
    Type type = responseType.getType();
    AsyncRequestCallback requestCallback = httpEntityCallback(requestEntity, type);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(type);
    return execute(url, method, requestCallback, responseExtractor, uriVariables);
}
org.springframework.web.client.AsyncRestTemplate
<T>@Override public ListenableFuture<ResponseEntity<T>> exchange(URI url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType)
{
    Type type = responseType.getType();
    AsyncRequestCallback requestCallback = httpEntityCallback(requestEntity, type);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(type);
    return execute(url, method, requestCallback, responseExtractor);
}
org.springframework.web.client.AsyncRestTemplate
<T>@Override public ListenableFuture<T> execute(String url, HttpMethod method, @Nullable AsyncRequestCallback requestCallback, @Nullable ResponseExtractor<T> responseExtractor, Object... uriVariables)
{
    URI expanded = getUriTemplateHandler().expand(url, uriVariables);
    return doExecute(expanded, method, requestCallback, responseExtractor);
}
org.springframework.web.client.AsyncRestTemplate
<T>@Override public ListenableFuture<T> execute(String url, HttpMethod method, @Nullable AsyncRequestCallback requestCallback, @Nullable ResponseExtractor<T> responseExtractor, Map<String, ?> uriVariables)
{
    URI expanded = getUriTemplateHandler().expand(url, uriVariables);
    return doExecute(expanded, method, requestCallback, responseExtractor);
}
org.springframework.web.client.AsyncRestTemplate
<T>@Override public ListenableFuture<T> execute(URI url, HttpMethod method, @Nullable AsyncRequestCallback requestCallback, @Nullable ResponseExtractor<T> responseExtractor)
{
    return doExecute(url, method, requestCallback, responseExtractor);
}
org.springframework.web.client.AsyncRestTemplate
public ResponseErrorHandler getErrorHandler()
{
    return this.syncTemplate.getErrorHandler();
}
org.springframework.web.client.AsyncRestTemplate
<T>@Override public ListenableFuture<ResponseEntity<T>> getForEntity(String url, Class<T> responseType, Map<String, ?> uriVariables)
{
    AsyncRequestCallback requestCallback = acceptHeaderRequestCallback(responseType);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
    return execute(url, HttpMethod.GET, requestCallback, responseExtractor, uriVariables);
}
org.springframework.web.client.AsyncRestTemplate
public List<HttpMessageConverter<?>> getMessageConverters()
{
    return this.syncTemplate.getMessageConverters();
}
org.springframework.web.client.AsyncRestTemplate
@Override public RestOperations getRestOperations()
{
    return this.syncTemplate;
}
org.springframework.web.client.AsyncRestTemplate
public UriTemplateHandler getUriTemplateHandler()
{
    return this.syncTemplate.getUriTemplateHandler();
}
org.springframework.web.client.AsyncRestTemplate
@Override public ListenableFuture<HttpHeaders> headForHeaders(String url, Object... uriVariables)
{
    ResponseExtractor<HttpHeaders> headersExtractor = headersExtractor();
    return execute(url, HttpMethod.HEAD, null, headersExtractor, uriVariables);
}
org.springframework.web.client.AsyncRestTemplate
@Override public ListenableFuture<HttpHeaders> headForHeaders(String url, Map<String, ?> uriVariables)
{
    ResponseExtractor<HttpHeaders> headersExtractor = headersExtractor();
    return execute(url, HttpMethod.HEAD, null, headersExtractor, uriVariables);
}
org.springframework.web.client.AsyncRestTemplate
@Override public ListenableFuture<HttpHeaders> headForHeaders(URI url)
{
    ResponseExtractor<HttpHeaders> headersExtractor = headersExtractor();
    return execute(url, HttpMethod.HEAD, null, headersExtractor);
}
org.springframework.web.client.AsyncRestTemplate
protected ResponseExtractor<HttpHeaders> headersExtractor()
{
    return this.syncTemplate.headersExtractor();
}
org.springframework.web.client.AsyncRestTemplate
<T>protected AsyncRequestCallback httpEntityCallback(@Nullable HttpEntity<T> requestBody)
{
    return new AsyncRequestCallbackAdapter(this.syncTemplate.httpEntityCallback(requestBody));
}
org.springframework.web.client.AsyncRestTemplate
<T>protected AsyncRequestCallback httpEntityCallback(@Nullable HttpEntity<T> request, Type responseType)
{
    return new AsyncRequestCallbackAdapter(this.syncTemplate.httpEntityCallback(request, responseType));
}
org.springframework.web.client.AsyncRestTemplate
@Override public ListenableFuture<Set<HttpMethod>> optionsForAllow(String url, Object... uriVars)
{
    ResponseExtractor<HttpHeaders> extractor = headersExtractor();
    ListenableFuture<HttpHeaders> future = execute(url, HttpMethod.OPTIONS, null, extractor, uriVars);
    return adaptToAllowHeader(future);
}
org.springframework.web.client.AsyncRestTemplate
@Override public ListenableFuture<Set<HttpMethod>> optionsForAllow(String url, Map<String, ?> uriVars)
{
    ResponseExtractor<HttpHeaders> extractor = headersExtractor();
    ListenableFuture<HttpHeaders> future = execute(url, HttpMethod.OPTIONS, null, extractor, uriVars);
    return adaptToAllowHeader(future);
}
org.springframework.web.client.AsyncRestTemplate
<T>@Override public ListenableFuture<ResponseEntity<T>> postForEntity(String url, @Nullable HttpEntity<?> request, Class<T> responseType, Object... uriVariables)
{
    AsyncRequestCallback requestCallback = httpEntityCallback(request, responseType);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
    return execute(url, HttpMethod.POST, requestCallback, responseExtractor, uriVariables);
}
org.springframework.web.client.AsyncRestTemplate
<T>@Override public ListenableFuture<ResponseEntity<T>> postForEntity(String url, @Nullable HttpEntity<?> request, Class<T> responseType, Map<String, ?> uriVariables)
{
    AsyncRequestCallback requestCallback = httpEntityCallback(request, responseType);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
    return execute(url, HttpMethod.POST, requestCallback, responseExtractor, uriVariables);
}
org.springframework.web.client.AsyncRestTemplate
<T>@Override public ListenableFuture<ResponseEntity<T>> postForEntity(URI url, @Nullable HttpEntity<?> request, Class<T> responseType)
{
    AsyncRequestCallback requestCallback = httpEntityCallback(request, responseType);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
    return execute(url, HttpMethod.POST, requestCallback, responseExtractor);
}
org.springframework.web.client.AsyncRestTemplate
@Override public ListenableFuture<?> put(String url, @Nullable HttpEntity<?> request, Object... uriVars)
{
    AsyncRequestCallback requestCallback = httpEntityCallback(request);
    return execute(url, HttpMethod.PUT, requestCallback, null, uriVars);
}
org.springframework.web.client.AsyncRestTemplate
@Override public ListenableFuture<?> put(String url, @Nullable HttpEntity<?> request, Map<String, ?> uriVars)
{
    AsyncRequestCallback requestCallback = httpEntityCallback(request);
    return execute(url, HttpMethod.PUT, requestCallback, null, uriVars);
}
org.springframework.web.client.AsyncRestTemplate
@Override public ListenableFuture<?> put(URI url, @Nullable HttpEntity<?> request)
{
    AsyncRequestCallback requestCallback = httpEntityCallback(request);
    return execute(url, HttpMethod.PUT, requestCallback, null);
}
org.springframework.web.client.AsyncRestTemplate
<T>protected ResponseExtractor<ResponseEntity<T>> responseEntityExtractor(Type responseType)
{
    return this.syncTemplate.responseEntityExtractor(responseType);
}
org.springframework.web.client.AsyncRestTemplate
public void setErrorHandler(ResponseErrorHandler errorHandler)
{
    this.syncTemplate.setErrorHandler(errorHandler);
}
org.springframework.web.client.AsyncRestTemplate
public void setMessageConverters(List<HttpMessageConverter<?>> messageConverters)
{
    this.syncTemplate.setMessageConverters(messageConverters);
}
org.springframework.web.client.AsyncRestTemplate
public void setUriTemplateHandler(UriTemplateHandler handler)
{
    this.syncTemplate.setUriTemplateHandler(handler);
}
 DefaultResponseErrorHandler
 implements ResponseErrorHandler
org.springframework.web.client.DefaultResponseErrorHandler
@Nullable protected Charset getCharset(ClientHttpResponse response)
{
    HttpHeaders headers = response.getHeaders();
    MediaType contentType = headers.getContentType();
    return (contentType != null ? contentType.getCharset() : null);
}
org.springframework.web.client.DefaultResponseErrorHandler
protected byte[] getResponseBody(ClientHttpResponse response)
{
    try {
        return FileCopyUtils.copyToByteArray(response.getBody());
    } catch (IOException ex) {
    }
    return new byte[0];
}
org.springframework.web.client.DefaultResponseErrorHandler
protected boolean hasError(HttpStatus statusCode)
{
    return statusCode.isError();
}
 ExtractingResponseErrorHandler
 extends DefaultResponseErrorHandler
org.springframework.web.client.ExtractingResponseErrorHandler
public ExtractingResponseErrorHandler ExtractingResponseErrorHandler()
{
}
org.springframework.web.client.ExtractingResponseErrorHandler
public ExtractingResponseErrorHandler ExtractingResponseErrorHandler(List<HttpMessageConverter<?>> messageConverters)
{
    this.messageConverters = messageConverters;
}
org.springframework.web.client.ExtractingResponseErrorHandler
@Override public void handleError(ClientHttpResponse response, HttpStatus statusCode)
{
    if (this.statusMapping.containsKey(statusCode)) {
        extract(this.statusMapping.get(statusCode), response);
    } else if (this.seriesMapping.containsKey(statusCode.series())) {
        extract(this.seriesMapping.get(statusCode.series()), response);
    } else {
        super.handleError(response, statusCode);
    }
}
org.springframework.web.client.ExtractingResponseErrorHandler
@Override protected boolean hasError(HttpStatus statusCode)
{
    if (this.statusMapping.containsKey(statusCode)) {
        return this.statusMapping.get(statusCode) != null;
    } else if (this.seriesMapping.containsKey(statusCode.series())) {
        return this.seriesMapping.get(statusCode.series()) != null;
    } else {
        return super.hasError(statusCode);
    }
}
org.springframework.web.client.ExtractingResponseErrorHandler
public void setMessageConverters(List<HttpMessageConverter<?>> messageConverters)
{
    this.messageConverters = messageConverters;
}
org.springframework.web.client.ExtractingResponseErrorHandler
public void setSeriesMapping(Map<HttpStatus.Series, Class<?>> seriesMapping)
{
    if (!CollectionUtils.isEmpty(seriesMapping)) {
        this.seriesMapping.putAll(seriesMapping);
    } 
}
org.springframework.web.client.ExtractingResponseErrorHandler
public void setStatusMapping(Map<HttpStatus, Class<?>> statusMapping)
{
    if (!CollectionUtils.isEmpty(statusMapping)) {
        this.statusMapping.putAll(statusMapping);
    } 
}
 HttpClientErrorException
 extends HttpStatusCodeException
 BadRequest
 extends HttpClientErrorException
 Conflict
 extends HttpClientErrorException
 Forbidden
 extends HttpClientErrorException
 Gone
 extends HttpClientErrorException
org.springframework.web.client.HttpClientErrorException
public HttpClientErrorException HttpClientErrorException(HttpStatus statusCode)
{
    super(statusCode);
}
org.springframework.web.client.HttpClientErrorException
public HttpClientErrorException HttpClientErrorException(HttpStatus statusCode, String statusText)
{
    super(statusCode, statusText);
}
org.springframework.web.client.HttpClientErrorException
public HttpClientErrorException HttpClientErrorException(HttpStatus statusCode, String statusText, @Nullable byte[] body, @Nullable Charset responseCharset)
{
    super(statusCode, statusText, body, responseCharset);
}
org.springframework.web.client.HttpClientErrorException
public HttpClientErrorException HttpClientErrorException(HttpStatus statusCode, String statusText, @Nullable HttpHeaders headers, @Nullable byte[] body, @Nullable Charset responseCharset)
{
    super(statusCode, statusText, headers, body, responseCharset);
}
 MethodNotAllowed
 extends HttpClientErrorException
 NotAcceptable
 extends HttpClientErrorException
 NotFound
 extends HttpClientErrorException
 TooManyRequests
 extends HttpClientErrorException
 Unauthorized
 extends HttpClientErrorException
 UnprocessableEntity
 extends HttpClientErrorException
 UnsupportedMediaType
 extends HttpClientErrorException
org.springframework.web.client.HttpClientErrorException
public static HttpClientErrorException create(HttpStatus statusCode, String statusText, HttpHeaders headers, byte[] body, @Nullable Charset charset)
{
    switch (statusCode) {
        case BAD_REQUEST:
            return new HttpClientErrorException.BadRequest(statusText, headers, body, charset);
        case UNAUTHORIZED:
            return new HttpClientErrorException.Unauthorized(statusText, headers, body, charset);
        case FORBIDDEN:
            return new HttpClientErrorException.Forbidden(statusText, headers, body, charset);
        case NOT_FOUND:
            return new HttpClientErrorException.NotFound(statusText, headers, body, charset);
        case METHOD_NOT_ALLOWED:
            return new HttpClientErrorException.MethodNotAllowed(statusText, headers, body, charset);
        case NOT_ACCEPTABLE:
            return new HttpClientErrorException.NotAcceptable(statusText, headers, body, charset);
        case CONFLICT:
            return new HttpClientErrorException.Conflict(statusText, headers, body, charset);
        case GONE:
            return new HttpClientErrorException.Gone(statusText, headers, body, charset);
        case UNSUPPORTED_MEDIA_TYPE:
            return new HttpClientErrorException.UnsupportedMediaType(statusText, headers, body, charset);
        case TOO_MANY_REQUESTS:
            return new HttpClientErrorException.TooManyRequests(statusText, headers, body, charset);
        case UNPROCESSABLE_ENTITY:
            return new HttpClientErrorException.UnprocessableEntity(statusText, headers, body, charset);
        default:
            return new HttpClientErrorException(statusCode, statusText, headers, body, charset);
    }
}
 HttpMessageConverterExtractor<T>
 implements ResponseExtractor<T>
org.springframework.web.client.HttpMessageConverterExtractor
public HttpMessageConverterExtractor HttpMessageConverterExtractor(Class<T> responseType, List<HttpMessageConverter<?>> messageConverters)
{
    this((Type)responseType, messageConverters);
}
org.springframework.web.client.HttpMessageConverterExtractor
public HttpMessageConverterExtractor HttpMessageConverterExtractor(Type responseType, List<HttpMessageConverter<?>> messageConverters)
{
    this(responseType, messageConverters, LogFactory.getLog(HttpMessageConverterExtractor.class));
}
org.springframework.web.client.HttpMessageConverterExtractor
@Override @SuppressWarnings({"unchecked","rawtypes","resource"}) public T extractData(ClientHttpResponse response)
{
    MessageBodyClientHttpResponseWrapper responseWrapper = new MessageBodyClientHttpResponseWrapper(response);
    if (!responseWrapper.hasMessageBody() || responseWrapper.hasEmptyMessageBody()) {
        return null;
    } 
    MediaType contentType = getContentType(responseWrapper);
    try {
        for (HttpMessageConverter<?> messageConverter: this.messageConverters) {
            if (messageConverter instanceof GenericHttpMessageConverter) {
                GenericHttpMessageConverter<?> genericMessageConverter = (GenericHttpMessageConverter<?>)messageConverter;
                if (genericMessageConverter.canRead(this.responseType, null, contentType)) {
                    if (logger.isDebugEnabled()) {
                        ResolvableType resolvableType = ResolvableType.forType(this.responseType);
                        logger.debug("Reading to [" + resolvableType + "]");
                    } 
                    return (T)genericMessageConverter.read(this.responseType, null, responseWrapper);
                } 
            } 
            if (this.responseClass != null) {
                if (messageConverter.canRead(this.responseClass, contentType)) {
                    if (logger.isDebugEnabled()) {
                        String className = this.responseClass.getName();
                        logger.debug("Reading to [" + className + "] as \"" + contentType + "\"");
                    } 
                    return (T)messageConverter.read((Class)this.responseClass, responseWrapper);
                } 
            } 
        }
    } catch (IOException | HttpMessageNotReadableException ex) {
        throw new RestClientException("Error while extracting response for type [" + this.responseType + "] and content type [" + contentType + "]", ex);
    }
    throw new RestClientException("Could not extract response: no suitable HttpMessageConverter found " + "for response type [" + this.responseType + "] and content type [" + contentType + "]");
}
org.springframework.web.client.HttpMessageConverterExtractor
@Nullable protected MediaType getContentType(ClientHttpResponse response)
{
    MediaType contentType = response.getHeaders().getContentType();
    if (contentType == null) {
        if (logger.isTraceEnabled()) {
            logger.trace("No content-type, using 'application/octet-stream'");
        } 
        contentType = MediaType.APPLICATION_OCTET_STREAM;
    } 
    return contentType;
}
 HttpServerErrorException
 extends HttpStatusCodeException
 BadGateway
 extends HttpServerErrorException
 GatewayTimeout
 extends HttpServerErrorException
org.springframework.web.client.HttpServerErrorException
public HttpServerErrorException HttpServerErrorException(HttpStatus statusCode)
{
    super(statusCode);
}
org.springframework.web.client.HttpServerErrorException
public HttpServerErrorException HttpServerErrorException(HttpStatus statusCode, String statusText)
{
    super(statusCode, statusText);
}
org.springframework.web.client.HttpServerErrorException
public HttpServerErrorException HttpServerErrorException(HttpStatus statusCode, String statusText, @Nullable byte[] body, @Nullable Charset charset)
{
    super(statusCode, statusText, body, charset);
}
org.springframework.web.client.HttpServerErrorException
public HttpServerErrorException HttpServerErrorException(HttpStatus statusCode, String statusText, @Nullable HttpHeaders headers, @Nullable byte[] body, @Nullable Charset charset)
{
    super(statusCode, statusText, headers, body, charset);
}
 InternalServerError
 extends HttpServerErrorException
 NotImplemented
 extends HttpServerErrorException
 ServiceUnavailable
 extends HttpServerErrorException
org.springframework.web.client.HttpServerErrorException
public static HttpServerErrorException create(HttpStatus statusCode, String statusText, HttpHeaders headers, byte[] body, @Nullable Charset charset)
{
    switch (statusCode) {
        case INTERNAL_SERVER_ERROR:
            return new HttpServerErrorException.InternalServerError(statusText, headers, body, charset);
        case NOT_IMPLEMENTED:
            return new HttpServerErrorException.NotImplemented(statusText, headers, body, charset);
        case BAD_GATEWAY:
            return new HttpServerErrorException.BadGateway(statusText, headers, body, charset);
        case SERVICE_UNAVAILABLE:
            return new HttpServerErrorException.ServiceUnavailable(statusText, headers, body, charset);
        case GATEWAY_TIMEOUT:
            return new HttpServerErrorException.GatewayTimeout(statusText, headers, body, charset);
        default:
            return new HttpServerErrorException(statusCode, statusText, headers, body, charset);
    }
}
 HttpStatusCodeException
 extends RestClientResponseException
org.springframework.web.client.HttpStatusCodeException
protected HttpStatusCodeException HttpStatusCodeException(HttpStatus statusCode)
{
    this(statusCode, statusCode.name(), null, null, null);
}
org.springframework.web.client.HttpStatusCodeException
protected HttpStatusCodeException HttpStatusCodeException(HttpStatus statusCode, String statusText)
{
    this(statusCode, statusText, null, null, null);
}
org.springframework.web.client.HttpStatusCodeException
protected HttpStatusCodeException HttpStatusCodeException(HttpStatus statusCode, String statusText, @Nullable byte[] responseBody, @Nullable Charset responseCharset)
{
    this(statusCode, statusText, null, responseBody, responseCharset);
}
org.springframework.web.client.HttpStatusCodeException
protected HttpStatusCodeException HttpStatusCodeException(HttpStatus statusCode, String statusText, @Nullable HttpHeaders responseHeaders, @Nullable byte[] responseBody, @Nullable Charset responseCharset)
{
    super(getMessage(statusCode, statusText), statusCode.value(), statusText, responseHeaders, responseBody, responseCharset);
    this.statusCode = statusCode;
}
org.springframework.web.client.HttpStatusCodeException
public HttpStatus getStatusCode()
{
    return this.statusCode;
}
 MessageBodyClientHttpResponseWrapper
 implements ClientHttpResponse
org.springframework.web.client.MessageBodyClientHttpResponseWrapper
public MessageBodyClientHttpResponseWrapper MessageBodyClientHttpResponseWrapper(ClientHttpResponse response)
{
    this.response = response;
}
org.springframework.web.client.MessageBodyClientHttpResponseWrapper
@Override public void close()
{
    this.response.close();
}
org.springframework.web.client.MessageBodyClientHttpResponseWrapper
@Override public InputStream getBody()
{
    return (this.pushbackInputStream != null ? this.pushbackInputStream : this.response.getBody());
}
org.springframework.web.client.MessageBodyClientHttpResponseWrapper
@Override public HttpHeaders getHeaders()
{
    return this.response.getHeaders();
}
org.springframework.web.client.MessageBodyClientHttpResponseWrapper
@Override public int getRawStatusCode()
{
    return this.response.getRawStatusCode();
}
org.springframework.web.client.MessageBodyClientHttpResponseWrapper
@Override public HttpStatus getStatusCode()
{
    return this.response.getStatusCode();
}
org.springframework.web.client.MessageBodyClientHttpResponseWrapper
@Override public String getStatusText()
{
    return this.response.getStatusText();
}
org.springframework.web.client.MessageBodyClientHttpResponseWrapper
public boolean hasMessageBody()
{
    HttpStatus status = HttpStatus.resolve(getRawStatusCode());
    if (status != null && (status.is1xxInformational() || status == HttpStatus.NO_CONTENT || status == HttpStatus.NOT_MODIFIED)) {
        return false;
    } 
    if (getHeaders().getContentLength() == 0) {
        return false;
    } 
    return true;
}
 RequestCallback
 ResourceAccessException
 extends RestClientException
org.springframework.web.client.ResourceAccessException
public ResourceAccessException ResourceAccessException(String msg)
{
    super(msg);
}
org.springframework.web.client.ResourceAccessException
public ResourceAccessException ResourceAccessException(String msg, IOException ex)
{
    super(msg, ex);
}
 ResponseErrorHandler
 ResponseExtractor
 RestClientException
 extends NestedRuntimeException
org.springframework.web.client.RestClientException
public RestClientException RestClientException(String msg)
{
    super(msg);
}
org.springframework.web.client.RestClientException
public RestClientException RestClientException(String msg, Throwable ex)
{
    super(msg, ex);
}
 RestClientResponseException
 extends RestClientException
org.springframework.web.client.RestClientResponseException
public RestClientResponseException RestClientResponseException(String message, int statusCode, String statusText, @Nullable HttpHeaders responseHeaders, @Nullable byte[] responseBody, @Nullable Charset responseCharset)
{
    super(message);
    this.rawStatusCode = statusCode;
    this.statusText = statusText;
    this.responseHeaders = responseHeaders;
    this.responseBody = (responseBody != null ? responseBody : new byte[0]);
    this.responseCharset = (responseCharset != null ? responseCharset.name() : null);
}
org.springframework.web.client.RestClientResponseException
public int getRawStatusCode()
{
    return this.rawStatusCode;
}
org.springframework.web.client.RestClientResponseException
public byte[] getResponseBodyAsByteArray()
{
    return this.responseBody;
}
org.springframework.web.client.RestClientResponseException
public String getResponseBodyAsString()
{
    if (this.responseCharset == null) {
        return new String(this.responseBody, DEFAULT_CHARSET);
    } 
    try {
        return new String(this.responseBody, this.responseCharset);
    } catch (UnsupportedEncodingException ex) {
        throw new IllegalStateException(ex);
    }
}
org.springframework.web.client.RestClientResponseException
@Nullable public HttpHeaders getResponseHeaders()
{
    return this.responseHeaders;
}
org.springframework.web.client.RestClientResponseException
public String getStatusText()
{
    return this.statusText;
}
 RestOperations
 RestTemplate
 extends InterceptingHttpAccessor implements RestOperations
org.springframework.web.client.RestTemplate
public RestTemplate RestTemplate(ClientHttpRequestFactory requestFactory)
{
    this();
    setRequestFactory(requestFactory);
}
org.springframework.web.client.RestTemplate
public RestTemplate RestTemplate(List<HttpMessageConverter<?>> messageConverters)
{
    validateConverters(messageConverters);
    this.messageConverters.addAll(messageConverters);
    this.uriTemplateHandler = initUriTemplateHandler();
}
org.springframework.web.client.RestTemplate
<T>public RequestCallback acceptHeaderRequestCallback(Class<T> responseType)
{
    return new AcceptHeaderRequestCallback(responseType);
}
org.springframework.web.client.RestTemplate
@Override public void delete(String url, Object... uriVariables)
{
    execute(url, HttpMethod.DELETE, null, null, uriVariables);
}
org.springframework.web.client.RestTemplate
@Override public void delete(String url, Map<String, ?> uriVariables)
{
    execute(url, HttpMethod.DELETE, null, null, uriVariables);
}
org.springframework.web.client.RestTemplate
@Override public void delete(URI url)
{
    execute(url, HttpMethod.DELETE, null, null);
}
org.springframework.web.client.RestTemplate
<T>@Nullable protected T doExecute(URI url, @Nullable HttpMethod method, @Nullable RequestCallback requestCallback, @Nullable ResponseExtractor<T> responseExtractor)
{
    Assert.notNull(url, "URI is required");
    Assert.notNull(method, "HttpMethod is required");
    ClientHttpResponse response = null;
    try {
        ClientHttpRequest request = createRequest(url, method);
        if (requestCallback != null) {
            requestCallback.doWithRequest(request);
        } 
        response = request.execute();
        handleResponse(url, method, response);
        return (responseExtractor != null ? responseExtractor.extractData(response) : null);
    } catch (IOException ex) {
        String resource = url.toString();
        String query = url.getRawQuery();
        resource = (query != null ? resource.substring(0, resource.indexOf('?')) : resource);
        throw new ResourceAccessException("I/O error on " + method.name() + " request for \"" + resource + "\": " + ex.getMessage(), ex);
    } finally {
        if (response != null) {
            response.close();
        } 
    }
}
org.springframework.web.client.RestTemplate
<T>@Override public ResponseEntity<T> exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables)
{
    RequestCallback requestCallback = httpEntityCallback(requestEntity, responseType);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
    return nonNull(execute(url, method, requestCallback, responseExtractor, uriVariables));
}
org.springframework.web.client.RestTemplate
<T>@Override public ResponseEntity<T> exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, Class<T> responseType, Map<String, ?> uriVariables)
{
    RequestCallback requestCallback = httpEntityCallback(requestEntity, responseType);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
    return nonNull(execute(url, method, requestCallback, responseExtractor, uriVariables));
}
org.springframework.web.client.RestTemplate
<T>@Override public ResponseEntity<T> exchange(URI url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, Class<T> responseType)
{
    RequestCallback requestCallback = httpEntityCallback(requestEntity, responseType);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
    return nonNull(execute(url, method, requestCallback, responseExtractor));
}
org.springframework.web.client.RestTemplate
<T>@Override public ResponseEntity<T> exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType, Object... uriVariables)
{
    Type type = responseType.getType();
    RequestCallback requestCallback = httpEntityCallback(requestEntity, type);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(type);
    return nonNull(execute(url, method, requestCallback, responseExtractor, uriVariables));
}
org.springframework.web.client.RestTemplate
<T>@Override public ResponseEntity<T> exchange(String url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables)
{
    Type type = responseType.getType();
    RequestCallback requestCallback = httpEntityCallback(requestEntity, type);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(type);
    return nonNull(execute(url, method, requestCallback, responseExtractor, uriVariables));
}
org.springframework.web.client.RestTemplate
<T>@Override public ResponseEntity<T> exchange(URI url, HttpMethod method, @Nullable HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType)
{
    Type type = responseType.getType();
    RequestCallback requestCallback = httpEntityCallback(requestEntity, type);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(type);
    return nonNull(execute(url, method, requestCallback, responseExtractor));
}
org.springframework.web.client.RestTemplate
<T>@Override @Nullable public T execute(String url, HttpMethod method, @Nullable RequestCallback requestCallback, @Nullable ResponseExtractor<T> responseExtractor, Object... uriVariables)
{
    URI expanded = getUriTemplateHandler().expand(url, uriVariables);
    return doExecute(expanded, method, requestCallback, responseExtractor);
}
org.springframework.web.client.RestTemplate
<T>@Override @Nullable public T execute(String url, HttpMethod method, @Nullable RequestCallback requestCallback, @Nullable ResponseExtractor<T> responseExtractor, Map<String, ?> uriVariables)
{
    URI expanded = getUriTemplateHandler().expand(url, uriVariables);
    return doExecute(expanded, method, requestCallback, responseExtractor);
}
org.springframework.web.client.RestTemplate
<T>@Override @Nullable public T execute(URI url, HttpMethod method, @Nullable RequestCallback requestCallback, @Nullable ResponseExtractor<T> responseExtractor)
{
    return doExecute(url, method, requestCallback, responseExtractor);
}
org.springframework.web.client.RestTemplate
public ResponseErrorHandler getErrorHandler()
{
    return this.errorHandler;
}
org.springframework.web.client.RestTemplate
public List<HttpMessageConverter<?>> getMessageConverters()
{
    return this.messageConverters;
}
org.springframework.web.client.RestTemplate
public UriTemplateHandler getUriTemplateHandler()
{
    return this.uriTemplateHandler;
}
org.springframework.web.client.RestTemplate
@Override public HttpHeaders headForHeaders(String url, Object... uriVariables)
{
    return nonNull(execute(url, HttpMethod.HEAD, null, headersExtractor(), uriVariables));
}
org.springframework.web.client.RestTemplate
@Override public HttpHeaders headForHeaders(String url, Map<String, ?> uriVariables)
{
    return nonNull(execute(url, HttpMethod.HEAD, null, headersExtractor(), uriVariables));
}
org.springframework.web.client.RestTemplate
@Override public HttpHeaders headForHeaders(URI url)
{
    return nonNull(execute(url, HttpMethod.HEAD, null, headersExtractor()));
}
org.springframework.web.client.RestTemplate
protected ResponseExtractor<HttpHeaders> headersExtractor()
{
    return this.headersExtractor;
}
org.springframework.web.client.RestTemplate
<T>public RequestCallback httpEntityCallback(@Nullable Object requestBody)
{
    return new HttpEntityRequestCallback(requestBody);
}
org.springframework.web.client.RestTemplate
<T>public RequestCallback httpEntityCallback(@Nullable Object requestBody, Type responseType)
{
    return new HttpEntityRequestCallback(requestBody, responseType);
}
org.springframework.web.client.RestTemplate
<T>@Override public ResponseEntity<T> postForEntity(String url, @Nullable Object request, Class<T> responseType, Map<String, ?> uriVariables)
{
    RequestCallback requestCallback = httpEntityCallback(request, responseType);
    ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
    return nonNull(execute(url, HttpMethod.POST, requestCallback, responseExtractor, uriVariables));
}
org.springframework.web.client.RestTemplate
@Override @Nullable public URI postForLocation(String url, @Nullable Object request, Map<String, ?> uriVariables)
{
    RequestCallback requestCallback = httpEntityCallback(request);
    HttpHeaders headers = execute(url, HttpMethod.POST, requestCallback, headersExtractor(), uriVariables);
    return (headers != null ? headers.getLocation() : null);
}
org.springframework.web.client.RestTemplate
@Override public void put(String url, @Nullable Object request, Object... uriVariables)
{
    RequestCallback requestCallback = httpEntityCallback(request);
    execute(url, HttpMethod.PUT, requestCallback, null, uriVariables);
}
org.springframework.web.client.RestTemplate
@Override public void put(String url, @Nullable Object request, Map<String, ?> uriVariables)
{
    RequestCallback requestCallback = httpEntityCallback(request);
    execute(url, HttpMethod.PUT, requestCallback, null, uriVariables);
}
org.springframework.web.client.RestTemplate
@Override public void put(URI url, @Nullable Object request)
{
    RequestCallback requestCallback = httpEntityCallback(request);
    execute(url, HttpMethod.PUT, requestCallback, null);
}
org.springframework.web.client.RestTemplate
<T>public ResponseExtractor<ResponseEntity<T>> responseEntityExtractor(Type responseType)
{
    return new ResponseEntityResponseExtractor<>(responseType);
}
org.springframework.web.client.RestTemplate
public void setErrorHandler(ResponseErrorHandler errorHandler)
{
    Assert.notNull(errorHandler, "ResponseErrorHandler must not be null");
    this.errorHandler = errorHandler;
}
org.springframework.web.client.RestTemplate
public void setMessageConverters(List<HttpMessageConverter<?>> messageConverters)
{
    validateConverters(messageConverters);
    if (this.messageConverters != messageConverters) {
        this.messageConverters.clear();
        this.messageConverters.addAll(messageConverters);
    } 
}
org.springframework.web.client.RestTemplate
public void setUriTemplateHandler(UriTemplateHandler handler)
{
    Assert.notNull(handler, "UriTemplateHandler must not be null");
    this.uriTemplateHandler = handler;
}
 UnknownHttpStatusCodeException
 extends RestClientResponseException
org.springframework.web.client.UnknownHttpStatusCodeException
public UnknownHttpStatusCodeException UnknownHttpStatusCodeException(int rawStatusCode, String statusText, @Nullable HttpHeaders responseHeaders, @Nullable byte[] responseBody, @Nullable Charset responseCharset)
{
    super("Unknown status code [" + rawStatusCode + "]" + " " + statusText, rawStatusCode, statusText, responseHeaders, responseBody, responseCharset);
}
 RestGatewaySupport
org.springframework.web.client.support.RestGatewaySupport
public RestGatewaySupport RestGatewaySupport()
{
    this.restTemplate = new RestTemplate();
}
org.springframework.web.client.support.RestGatewaySupport
public RestGatewaySupport RestGatewaySupport(ClientHttpRequestFactory requestFactory)
{
    Assert.notNull(requestFactory, "'requestFactory' must not be null");
    this.restTemplate = new RestTemplate(requestFactory);
}
org.springframework.web.client.support.RestGatewaySupport
public RestTemplate getRestTemplate()
{
    return this.restTemplate;
}
org.springframework.web.client.support.RestGatewaySupport
protected final Log logger
org.springframework.web.client.support.RestGatewaySupport
public void setRestTemplate(RestTemplate restTemplate)
{
    Assert.notNull(restTemplate, "'restTemplate' must not be null");
    this.restTemplate = restTemplate;
}
 AbstractContextLoaderInitializer
 implements WebApplicationInitializer
org.springframework.web.context.AbstractContextLoaderInitializer
@Nullable protected abstract WebApplicationContext createRootApplicationContext()
org.springframework.web.context.AbstractContextLoaderInitializer
@Nullable protected ApplicationContextInitializer<?>[] getRootApplicationContextInitializers()
{
    return null;
}
org.springframework.web.context.AbstractContextLoaderInitializer
protected final Log logger
org.springframework.web.context.AbstractContextLoaderInitializer
@Override public void onStartup(ServletContext servletContext)
{
    registerContextLoaderListener(servletContext);
}
 ConfigurableWebApplicationContext
inherit classes
  • WebApplicationContext
  • ConfigurableApplicationContext
 ConfigurableWebEnvironment
inherit classes
  • ConfigurableEnvironment
 ContextCleanupListener
 implements ServletContextListener
org.springframework.web.context.ContextCleanupListener
@Override public void contextDestroyed(ServletContextEvent event)
{
    cleanupAttributes(event.getServletContext());
}
org.springframework.web.context.ContextCleanupListener
@Override public void contextInitialized(ServletContextEvent event)
{
}
 ContextLoader
org.springframework.web.context.ContextLoader
public static final String CONFIG_LOCATION_PARAM
org.springframework.web.context.ContextLoader
public static final String CONTEXT_CLASS_PARAM
org.springframework.web.context.ContextLoader
public static final String CONTEXT_ID_PARAM
org.springframework.web.context.ContextLoader
public static final String CONTEXT_INITIALIZER_CLASSES_PARAM
org.springframework.web.context.ContextLoader
public ContextLoader ContextLoader()
{
}
org.springframework.web.context.ContextLoader
public ContextLoader ContextLoader(WebApplicationContext context)
{
    this.context = context;
}
org.springframework.web.context.ContextLoader
public static final String GLOBAL_INITIALIZER_CLASSES_PARAM
org.springframework.web.context.ContextLoader
protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc)
{
    if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
        String idParam = sc.getInitParameter(CONTEXT_ID_PARAM);
        if (idParam != null) {
            wac.setId(idParam);
        } else {
            wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX + ObjectUtils.getDisplayString(sc.getContextPath()));
        }
    } 
    wac.setServletContext(sc);
    String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM);
    if (configLocationParam != null) {
        wac.setConfigLocation(configLocationParam);
    } 
    ConfigurableEnvironment env = wac.getEnvironment();
    if (env instanceof ConfigurableWebEnvironment) {
        ((ConfigurableWebEnvironment)env).initPropertySources(sc, null);
    } 
    customizeContext(sc, wac);
    wac.refresh();
}
org.springframework.web.context.ContextLoader
protected WebApplicationContext createWebApplicationContext(ServletContext sc)
{
    Class<?> contextClass = determineContextClass(sc);
    if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
        throw new ApplicationContextException("Custom context class [" + contextClass.getName() + "] is not of type [" + ConfigurableWebApplicationContext.class.getName() + "]");
    } 
    return (ConfigurableWebApplicationContext)BeanUtils.instantiateClass(contextClass);
}
org.springframework.web.context.ContextLoader
@Nullable volatile static WebApplicationContext currentContext
org.springframework.web.context.ContextLoader
@Nullable public static WebApplicationContext getCurrentWebApplicationContext()
{
    ClassLoader ccl = Thread.currentThread().getContextClassLoader();
    if (ccl != null) {
        WebApplicationContext ccpt = currentContextPerThread.get(ccl);
        if (ccpt != null) {
            return ccpt;
        } 
    } 
    return currentContext;
}
org.springframework.web.context.ContextLoader
public WebApplicationContext initWebApplicationContext(ServletContext servletContext)
{
    if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {
        throw new IllegalStateException("Cannot initialize context because there is already a root application context present - " + "check whether you have multiple ContextLoader* definitions in your web.xml!");
    } 
    servletContext.log("Initializing Spring root WebApplicationContext");
    Log logger = LogFactory.getLog(ContextLoader.class);
    if (logger.isInfoEnabled()) {
        logger.info("Root WebApplicationContext: initialization started");
    } 
    long startTime = System.currentTimeMillis();
    try {
        if (this.context == null) {
            this.context = createWebApplicationContext(servletContext);
        } 
        if (this.context instanceof ConfigurableWebApplicationContext) {
            ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext)this.context;
            if (!cwac.isActive()) {
                if (cwac.getParent() == null) {
                    ApplicationContext parent = loadParentContext(servletContext);
                    cwac.setParent(parent);
                } 
                configureAndRefreshWebApplicationContext(cwac, servletContext);
            } 
        } 
        servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
        ClassLoader ccl = Thread.currentThread().getContextClassLoader();
        if (ccl == ContextLoader.class.getClassLoader()) {
            currentContext = this.context;
        } else if (ccl != null) {
            currentContextPerThread.put(ccl, this.context);
        } 
        if (logger.isInfoEnabled()) {
            long elapsedTime = System.currentTimeMillis() - startTime;
            logger.info("Root WebApplicationContext initialized in " + elapsedTime + " ms");
        } 
        return this.context;
    } catch (RuntimeException | Error ex) {
        logger.error("Context initialization failed", ex);
        servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
        throw ex;
    }
}
org.springframework.web.context.ContextLoader
@Nullable protected ApplicationContext loadParentContext(ServletContext servletContext)
{
    return null;
}
org.springframework.web.context.ContextLoader
@SuppressWarnings("unchecked") public void setContextInitializers(@Nullable ApplicationContextInitializer<?>... initializers)
{
    if (initializers != null) {
        for (ApplicationContextInitializer<?> initializer: initializers) {
            this.contextInitializers.add((ApplicationContextInitializer<ConfigurableApplicationContext>)initializer);
        }
    } 
}
 ContextLoaderListener
 extends ContextLoader implements ServletContextListener
org.springframework.web.context.ContextLoaderListener
public ContextLoaderListener ContextLoaderListener()
{
}
org.springframework.web.context.ContextLoaderListener
public ContextLoaderListener ContextLoaderListener(WebApplicationContext context)
{
    super(context);
}
org.springframework.web.context.ContextLoaderListener
@Override public void contextDestroyed(ServletContextEvent event)
{
    closeWebApplicationContext(event.getServletContext());
    ContextCleanupListener.cleanupAttributes(event.getServletContext());
}
org.springframework.web.context.ContextLoaderListener
@Override public void contextInitialized(ServletContextEvent event)
{
    initWebApplicationContext(event.getServletContext());
}
 ServletConfigAware
inherit classes
  • Aware
 ServletContextAware
inherit classes
  • Aware
 WebApplicationContext
inherit classes
  • ApplicationContext
@ApplicationScope
org.springframework.web.context.annotation.ApplicationScope
@AliasFor(annotation=Scope.class) private ScopedProxyMode proxyMode()
@RequestScope
org.springframework.web.context.annotation.RequestScope
@AliasFor(annotation=Scope.class) private ScopedProxyMode proxyMode()
@SessionScope
org.springframework.web.context.annotation.SessionScope
@AliasFor(annotation=Scope.class) private ScopedProxyMode proxyMode()
 AbstractRequestAttributes
 implements RequestAttributes
org.springframework.web.context.request.AbstractRequestAttributes
protected final boolean isRequestActive()
{
    return this.requestActive;
}
org.springframework.web.context.request.AbstractRequestAttributes
protected final void registerRequestDestructionCallback(String name, Runnable callback)
{
    Assert.notNull(name, "Name must not be null");
    Assert.notNull(callback, "Callback must not be null");
    synchronized(this.requestDestructionCallbacks) {
        this.requestDestructionCallbacks.put(name, callback);
    }
}
org.springframework.web.context.request.AbstractRequestAttributes
protected final void removeRequestDestructionCallback(String name)
{
    Assert.notNull(name, "Name must not be null");
    synchronized(this.requestDestructionCallbacks) {
        this.requestDestructionCallbacks.remove(name);
    }
}
org.springframework.web.context.request.AbstractRequestAttributes
volatile boolean requestActive
org.springframework.web.context.request.AbstractRequestAttributes
public void requestCompleted()
{
    executeRequestDestructionCallbacks();
    updateAccessedSessionAttributes();
    this.requestActive = false;
}
org.springframework.web.context.request.AbstractRequestAttributes
protected final Map<String, Runnable> requestDestructionCallbacks
org.springframework.web.context.request.AbstractRequestAttributes
protected abstract void updateAccessedSessionAttributes()
 AbstractRequestAttributesScope
 implements Scope
org.springframework.web.context.request.AbstractRequestAttributesScope
protected abstract int getScope()
org.springframework.web.context.request.AbstractRequestAttributesScope
@Override public void registerDestructionCallback(String name, Runnable callback)
{
    RequestAttributes attributes = RequestContextHolder.currentRequestAttributes();
    attributes.registerDestructionCallback(name, callback, getScope());
}
org.springframework.web.context.request.AbstractRequestAttributesScope
@Override @Nullable public Object resolveContextualObject(String key)
{
    RequestAttributes attributes = RequestContextHolder.currentRequestAttributes();
    return attributes.resolveReference(key);
}
 AsyncWebRequestInterceptor
inherit classes
  • WebRequestInterceptor
 DestructionCallbackBindingListener
 implements HttpSessionBindingListener, Serializable
org.springframework.web.context.request.DestructionCallbackBindingListener
public DestructionCallbackBindingListener DestructionCallbackBindingListener(Runnable destructionCallback)
{
    this.destructionCallback = destructionCallback;
}
org.springframework.web.context.request.DestructionCallbackBindingListener
@Override public void valueBound(HttpSessionBindingEvent event)
{
}
org.springframework.web.context.request.DestructionCallbackBindingListener
@Override public void valueUnbound(HttpSessionBindingEvent event)
{
    this.destructionCallback.run();
}
 FacesRequestAttributes
 implements RequestAttributes
org.springframework.web.context.request.FacesRequestAttributes
public FacesRequestAttributes FacesRequestAttributes(FacesContext facesContext)
{
    Assert.notNull(facesContext, "FacesContext must not be null");
    this.facesContext = facesContext;
}
org.springframework.web.context.request.FacesRequestAttributes
@Override public Object getAttribute(String name, int scope)
{
    return getAttributeMap(scope).get(name);
}
org.springframework.web.context.request.FacesRequestAttributes
protected Map<String, Object> getAttributeMap(int scope)
{
    if (scope == SCOPE_REQUEST) {
        return getExternalContext().getRequestMap();
    } else {
        return getExternalContext().getSessionMap();
    }
}
org.springframework.web.context.request.FacesRequestAttributes
@Override public String[] getAttributeNames(int scope)
{
    return StringUtils.toStringArray(getAttributeMap(scope).keySet());
}
org.springframework.web.context.request.FacesRequestAttributes
protected final ExternalContext getExternalContext()
{
    return getFacesContext().getExternalContext();
}
org.springframework.web.context.request.FacesRequestAttributes
protected final FacesContext getFacesContext()
{
    return this.facesContext;
}
org.springframework.web.context.request.FacesRequestAttributes
@Override public void registerDestructionCallback(String name, Runnable callback, int scope)
{
    if (logger.isWarnEnabled()) {
        logger.warn("Could not register destruction callback [" + callback + "] for attribute '" + name + "' because FacesRequestAttributes does not support such callbacks");
    } 
}
org.springframework.web.context.request.FacesRequestAttributes
@Override public void removeAttribute(String name, int scope)
{
    getAttributeMap(scope).remove(name);
}
org.springframework.web.context.request.FacesRequestAttributes
@Override public Object resolveReference(String key)
{
    if (REFERENCE_REQUEST.equals(key)) {
        return getExternalContext().getRequest();
    } else if (REFERENCE_SESSION.equals(key)) {
        return getExternalContext().getSession(true);
    } else if ("application".equals(key)) {
        return getExternalContext().getContext();
    } else if ("requestScope".equals(key)) {
        return getExternalContext().getRequestMap();
    } else if ("sessionScope".equals(key)) {
        return getExternalContext().getSessionMap();
    } else if ("applicationScope".equals(key)) {
        return getExternalContext().getApplicationMap();
    } else if ("facesContext".equals(key)) {
        return getFacesContext();
    } else if ("cookie".equals(key)) {
        return getExternalContext().getRequestCookieMap();
    } else if ("header".equals(key)) {
        return getExternalContext().getRequestHeaderMap();
    } else if ("headerValues".equals(key)) {
        return getExternalContext().getRequestHeaderValuesMap();
    } else if ("param".equals(key)) {
        return getExternalContext().getRequestParameterMap();
    } else if ("paramValues".equals(key)) {
        return getExternalContext().getRequestParameterValuesMap();
    } else if ("initParam".equals(key)) {
        return getExternalContext().getInitParameterMap();
    } else if ("view".equals(key)) {
        return getFacesContext().getViewRoot();
    } else if ("viewScope".equals(key)) {
        return getFacesContext().getViewRoot().getViewMap();
    } else if ("flash".equals(key)) {
        return getExternalContext().getFlash();
    } else if ("resource".equals(key)) {
        return getFacesContext().getApplication().getResourceHandler();
    } else {
        return null;
    }
}
org.springframework.web.context.request.FacesRequestAttributes
@Override public void setAttribute(String name, Object value, int scope)
{
    getAttributeMap(scope).put(name, value);
}
 FacesWebRequest
 extends FacesRequestAttributes implements NativeWebRequest
org.springframework.web.context.request.FacesWebRequest
public FacesWebRequest FacesWebRequest(FacesContext facesContext)
{
    super(facesContext);
}
org.springframework.web.context.request.FacesWebRequest
@Override public boolean checkNotModified(long lastModifiedTimestamp)
{
    return false;
}
org.springframework.web.context.request.FacesWebRequest
@Override public boolean checkNotModified(@Nullable String eTag)
{
    return false;
}
org.springframework.web.context.request.FacesWebRequest
@Override public boolean checkNotModified(@Nullable String etag, long lastModifiedTimestamp)
{
    return false;
}
org.springframework.web.context.request.FacesWebRequest
@Override public String getContextPath()
{
    return getFacesContext().getExternalContext().getRequestContextPath();
}
org.springframework.web.context.request.FacesWebRequest
@Override @Nullable public String getHeader(String headerName)
{
    return getExternalContext().getRequestHeaderMap().get(headerName);
}
org.springframework.web.context.request.FacesWebRequest
@Override public Iterator<String> getHeaderNames()
{
    return getExternalContext().getRequestHeaderMap().keySet().iterator();
}
org.springframework.web.context.request.FacesWebRequest
@Override @Nullable public String[] getHeaderValues(String headerName)
{
    return getExternalContext().getRequestHeaderValuesMap().get(headerName);
}
org.springframework.web.context.request.FacesWebRequest
@Override public Locale getLocale()
{
    return getFacesContext().getExternalContext().getRequestLocale();
}
org.springframework.web.context.request.FacesWebRequest
@Override public Object getNativeRequest()
{
    return getExternalContext().getRequest();
}
org.springframework.web.context.request.FacesWebRequest
<T>@Override @SuppressWarnings("unchecked") public T getNativeRequest(@Nullable Class<T> requiredType)
{
    if (requiredType != null) {
        Object request = getExternalContext().getRequest();
        if (requiredType.isInstance(request)) {
            return (T)request;
        } 
    } 
    return null;
}
org.springframework.web.context.request.FacesWebRequest
@Override public Object getNativeResponse()
{
    return getExternalContext().getResponse();
}
org.springframework.web.context.request.FacesWebRequest
<T>@Override @SuppressWarnings("unchecked") public T getNativeResponse(@Nullable Class<T> requiredType)
{
    if (requiredType != null) {
        Object response = getExternalContext().getResponse();
        if (requiredType.isInstance(response)) {
            return (T)response;
        } 
    } 
    return null;
}
org.springframework.web.context.request.FacesWebRequest
@Override @Nullable public String getParameter(String paramName)
{
    return getExternalContext().getRequestParameterMap().get(paramName);
}
org.springframework.web.context.request.FacesWebRequest
@Override public Map<String, String[]> getParameterMap()
{
    return getExternalContext().getRequestParameterValuesMap();
}
org.springframework.web.context.request.FacesWebRequest
@Override public Iterator<String> getParameterNames()
{
    return getExternalContext().getRequestParameterNames();
}
org.springframework.web.context.request.FacesWebRequest
@Override @Nullable public String[] getParameterValues(String paramName)
{
    return getExternalContext().getRequestParameterValuesMap().get(paramName);
}
org.springframework.web.context.request.FacesWebRequest
@Override @Nullable public String getRemoteUser()
{
    return getFacesContext().getExternalContext().getRemoteUser();
}
org.springframework.web.context.request.FacesWebRequest
@Override @Nullable public Principal getUserPrincipal()
{
    return getFacesContext().getExternalContext().getUserPrincipal();
}
org.springframework.web.context.request.FacesWebRequest
@Override public boolean isSecure()
{
    return false;
}
org.springframework.web.context.request.FacesWebRequest
@Override public boolean isUserInRole(String role)
{
    return getFacesContext().getExternalContext().isUserInRole(role);
}
org.springframework.web.context.request.FacesWebRequest
@Override public String toString()
{
    return "FacesWebRequest: " + getDescription(true);
}
 NativeWebRequest
inherit classes
  • WebRequest
 RequestAttributes
 RequestContextHolder
org.springframework.web.context.request.RequestContextHolder
@Nullable public static RequestAttributes getRequestAttributes()
{
    RequestAttributes attributes = requestAttributesHolder.get();
    if (attributes == null) {
        attributes = inheritableRequestAttributesHolder.get();
    } 
    return attributes;
}
org.springframework.web.context.request.RequestContextHolder
public static void resetRequestAttributes()
{
    requestAttributesHolder.remove();
    inheritableRequestAttributesHolder.remove();
}
org.springframework.web.context.request.RequestContextHolder
public static void setRequestAttributes(@Nullable RequestAttributes attributes)
{
    setRequestAttributes(attributes, false);
}
org.springframework.web.context.request.RequestContextHolder
public static void setRequestAttributes(@Nullable RequestAttributes attributes, boolean inheritable)
{
    if (attributes == null) {
        resetRequestAttributes();
    } else {
        if (inheritable) {
            inheritableRequestAttributesHolder.set(attributes);
            requestAttributesHolder.remove();
        } else {
            requestAttributesHolder.set(attributes);
            inheritableRequestAttributesHolder.remove();
        }
    }
}
 RequestContextListener
 implements ServletRequestListener
org.springframework.web.context.request.RequestContextListener
@Override public void requestInitialized(ServletRequestEvent requestEvent)
{
    if (!(requestEvent.getServletRequest() instanceof HttpServletRequest)) {
        throw new IllegalArgumentException("Request is not an HttpServletRequest: " + requestEvent.getServletRequest());
    } 
    HttpServletRequest request = (HttpServletRequest)requestEvent.getServletRequest();
    ServletRequestAttributes attributes = new ServletRequestAttributes(request);
    request.setAttribute(REQUEST_ATTRIBUTES_ATTRIBUTE, attributes);
    LocaleContextHolder.setLocale(request.getLocale());
    RequestContextHolder.setRequestAttributes(attributes);
}
 RequestScope
 extends AbstractRequestAttributesScope
org.springframework.web.context.request.RequestScope
@Override @Nullable public String getConversationId()
{
    return null;
}
org.springframework.web.context.request.RequestScope
@Override protected int getScope()
{
    return RequestAttributes.SCOPE_REQUEST;
}
 ServletRequestAttributes
 extends AbstractRequestAttributes
org.springframework.web.context.request.ServletRequestAttributes
public static final String DESTRUCTION_CALLBACK_NAME_PREFIX
org.springframework.web.context.request.ServletRequestAttributes
public ServletRequestAttributes ServletRequestAttributes(HttpServletRequest request)
{
    Assert.notNull(request, "Request must not be null");
    this.request = request;
}
org.springframework.web.context.request.ServletRequestAttributes
public ServletRequestAttributes ServletRequestAttributes(HttpServletRequest request, @Nullable HttpServletResponse response)
{
    this(request);
    this.response = response;
}
org.springframework.web.context.request.ServletRequestAttributes
@Override public Object getAttribute(String name, int scope)
{
    if (scope == SCOPE_REQUEST) {
        if (!isRequestActive()) {
            throw new IllegalStateException("Cannot ask for request attribute - request is not active anymore!");
        } 
        return this.request.getAttribute(name);
    } else {
        HttpSession session = getSession(false);
        if (session != null) {
            try {
                Object value = session.getAttribute(name);
                if (value != null) {
                    this.sessionAttributesToUpdate.put(name, value);
                } 
                return value;
            } catch (IllegalStateException ex) {
            }
        } 
        return null;
    }
}
org.springframework.web.context.request.ServletRequestAttributes
@Override public String[] getAttributeNames(int scope)
{
    if (scope == SCOPE_REQUEST) {
        if (!isRequestActive()) {
            throw new IllegalStateException("Cannot ask for request attributes - request is not active anymore!");
        } 
        return StringUtils.toStringArray(this.request.getAttributeNames());
    } else {
        HttpSession session = getSession(false);
        if (session != null) {
            try {
                return StringUtils.toStringArray(session.getAttributeNames());
            } catch (IllegalStateException ex) {
            }
        } 
        return new String[0];
    }
}
org.springframework.web.context.request.ServletRequestAttributes
public final HttpServletRequest getRequest()
{
    return this.request;
}
org.springframework.web.context.request.ServletRequestAttributes
@Nullable public final HttpServletResponse getResponse()
{
    return this.response;
}
org.springframework.web.context.request.ServletRequestAttributes
@Override public String getSessionId()
{
    return obtainSession().getId();
}
org.springframework.web.context.request.ServletRequestAttributes
@Override public Object getSessionMutex()
{
    return WebUtils.getSessionMutex(obtainSession());
}
org.springframework.web.context.request.ServletRequestAttributes
protected static final Set<Class<?>> immutableValueTypes
org.springframework.web.context.request.ServletRequestAttributes
protected boolean isImmutableSessionAttribute(String name, @Nullable Object value)
{
    return (value == null || immutableValueTypes.contains(value.getClass()));
}
org.springframework.web.context.request.ServletRequestAttributes
@Override public void registerDestructionCallback(String name, Runnable callback, int scope)
{
    if (scope == SCOPE_REQUEST) {
        registerRequestDestructionCallback(name, callback);
    } else {
        registerSessionDestructionCallback(name, callback);
    }
}
org.springframework.web.context.request.ServletRequestAttributes
protected void registerSessionDestructionCallback(String name, Runnable callback)
{
    HttpSession session = obtainSession();
    session.setAttribute(DESTRUCTION_CALLBACK_NAME_PREFIX + name, new DestructionCallbackBindingListener(callback));
}
org.springframework.web.context.request.ServletRequestAttributes
@Override public Object resolveReference(String key)
{
    if (REFERENCE_REQUEST.equals(key)) {
        return this.request;
    } else if (REFERENCE_SESSION.equals(key)) {
        return getSession(true);
    } else {
        return null;
    }
}
org.springframework.web.context.request.ServletRequestAttributes
@Nullable volatile HttpSession session
org.springframework.web.context.request.ServletRequestAttributes
@Override public void setAttribute(String name, Object value, int scope)
{
    if (scope == SCOPE_REQUEST) {
        if (!isRequestActive()) {
            throw new IllegalStateException("Cannot set request attribute - request is not active anymore!");
        } 
        this.request.setAttribute(name, value);
    } else {
        HttpSession session = obtainSession();
        this.sessionAttributesToUpdate.remove(name);
        session.setAttribute(name, value);
    }
}
org.springframework.web.context.request.ServletRequestAttributes
@Override public String toString()
{
    return this.request.toString();
}
 ServletWebRequest
 extends ServletRequestAttributes implements NativeWebRequest
org.springframework.web.context.request.ServletWebRequest
public ServletWebRequest ServletWebRequest(HttpServletRequest request)
{
    super(request);
}
org.springframework.web.context.request.ServletWebRequest
public ServletWebRequest ServletWebRequest(HttpServletRequest request, @Nullable HttpServletResponse response)
{
    super(request, response);
}
org.springframework.web.context.request.ServletWebRequest
@Override public boolean checkNotModified(long lastModifiedTimestamp)
{
    return checkNotModified(null, lastModifiedTimestamp);
}
org.springframework.web.context.request.ServletWebRequest
@Override public boolean checkNotModified(String etag)
{
    return checkNotModified(etag, -1);
}
org.springframework.web.context.request.ServletWebRequest
@Override public String getContextPath()
{
    return getRequest().getContextPath();
}
org.springframework.web.context.request.ServletWebRequest
@Override public String getDescription(boolean includeClientInfo)
{
    HttpServletRequest request = getRequest();
    StringBuilder sb = new StringBuilder();
    sb.append("uri=").append(request.getRequestURI());
    if (includeClientInfo) {
        String client = request.getRemoteAddr();
        if (StringUtils.hasLength(client)) {
            sb.append(";client=").append(client);
        } 
        HttpSession session = request.getSession(false);
        if (session != null) {
            sb.append(";session=").append(session.getId());
        } 
        String user = request.getRemoteUser();
        if (StringUtils.hasLength(user)) {
            sb.append(";user=").append(user);
        } 
    } 
    return sb.toString();
}
org.springframework.web.context.request.ServletWebRequest
@Override @Nullable public String getHeader(String headerName)
{
    return getRequest().getHeader(headerName);
}
org.springframework.web.context.request.ServletWebRequest
@Override public Iterator<String> getHeaderNames()
{
    return CollectionUtils.toIterator(getRequest().getHeaderNames());
}
org.springframework.web.context.request.ServletWebRequest
@Override @Nullable public String[] getHeaderValues(String headerName)
{
    String[] headerValues = StringUtils.toStringArray(getRequest().getHeaders(headerName));
    return (!ObjectUtils.isEmpty(headerValues) ? headerValues : null);
}
org.springframework.web.context.request.ServletWebRequest
@Nullable public HttpMethod getHttpMethod()
{
    return HttpMethod.resolve(getRequest().getMethod());
}
org.springframework.web.context.request.ServletWebRequest
@Override public Locale getLocale()
{
    return getRequest().getLocale();
}
org.springframework.web.context.request.ServletWebRequest
@Override public Object getNativeRequest()
{
    return getRequest();
}
org.springframework.web.context.request.ServletWebRequest
<T>@Override public T getNativeRequest(@Nullable Class<T> requiredType)
{
    return WebUtils.getNativeRequest(getRequest(), requiredType);
}
org.springframework.web.context.request.ServletWebRequest
@Override public Object getNativeResponse()
{
    return getResponse();
}
org.springframework.web.context.request.ServletWebRequest
<T>@Override public T getNativeResponse(@Nullable Class<T> requiredType)
{
    HttpServletResponse response = getResponse();
    return (response != null ? WebUtils.getNativeResponse(response, requiredType) : null);
}
org.springframework.web.context.request.ServletWebRequest
@Override @Nullable public String getParameter(String paramName)
{
    return getRequest().getParameter(paramName);
}
org.springframework.web.context.request.ServletWebRequest
@Override public Map<String, String[]> getParameterMap()
{
    return getRequest().getParameterMap();
}
org.springframework.web.context.request.ServletWebRequest
@Override public Iterator<String> getParameterNames()
{
    return CollectionUtils.toIterator(getRequest().getParameterNames());
}
org.springframework.web.context.request.ServletWebRequest
@Override @Nullable public String[] getParameterValues(String paramName)
{
    return getRequest().getParameterValues(paramName);
}
org.springframework.web.context.request.ServletWebRequest
@Override @Nullable public String getRemoteUser()
{
    return getRequest().getRemoteUser();
}
org.springframework.web.context.request.ServletWebRequest
@Override @Nullable public Principal getUserPrincipal()
{
    return getRequest().getUserPrincipal();
}
org.springframework.web.context.request.ServletWebRequest
public boolean isNotModified()
{
    return this.notModified;
}
org.springframework.web.context.request.ServletWebRequest
@Override public boolean isSecure()
{
    return getRequest().isSecure();
}
org.springframework.web.context.request.ServletWebRequest
@Override public boolean isUserInRole(String role)
{
    return getRequest().isUserInRole(role);
}
org.springframework.web.context.request.ServletWebRequest
@Override public String toString()
{
    return "ServletWebRequest: " + getDescription(true);
}
 SessionScope
 extends AbstractRequestAttributesScope
org.springframework.web.context.request.SessionScope
@Override public Object get(String name, ObjectFactory<?> objectFactory)
{
    Object mutex = RequestContextHolder.currentRequestAttributes().getSessionMutex();
    synchronized(mutex) {
        return super.get(name, objectFactory);
    }
}
org.springframework.web.context.request.SessionScope
@Override public String getConversationId()
{
    return RequestContextHolder.currentRequestAttributes().getSessionId();
}
org.springframework.web.context.request.SessionScope
@Override protected int getScope()
{
    return RequestAttributes.SCOPE_SESSION;
}
org.springframework.web.context.request.SessionScope
@Override @Nullable public Object remove(String name)
{
    Object mutex = RequestContextHolder.currentRequestAttributes().getSessionMutex();
    synchronized(mutex) {
        return super.remove(name);
    }
}
 WebRequest
inherit classes
  • RequestAttributes
 WebRequestInterceptor
 AsyncRequestTimeoutException
 extends RuntimeException
 AsyncWebRequest
inherit classes
  • NativeWebRequest
 CallableInterceptorChain
org.springframework.web.context.request.async.CallableInterceptorChain
public CallableInterceptorChain CallableInterceptorChain(List<CallableProcessingInterceptor> interceptors)
{
    this.interceptors = interceptors;
}
org.springframework.web.context.request.async.CallableInterceptorChain
public void applyBeforeConcurrentHandling(NativeWebRequest request, Callable<?> task)
{
    for (CallableProcessingInterceptor interceptor: this.interceptors) {
        interceptor.beforeConcurrentHandling(request, task);
    }
}
org.springframework.web.context.request.async.CallableInterceptorChain
public Object applyPostProcess(NativeWebRequest request, Callable<?> task, Object concurrentResult)
{
    Throwable exceptionResult = null;
    for (int i = this.preProcessIndex; i >= 0; i--) {
        try {
            this.interceptors.get(i).postProcess(request, task, concurrentResult);
        } catch (Throwable ex) {
            if (exceptionResult != null) {
                if (logger.isTraceEnabled()) {
                    logger.trace("Ignoring failure in postProcess method", ex);
                } 
            } else {
                exceptionResult = ex;
            }
        }
    }
    return (exceptionResult != null) ? exceptionResult : concurrentResult;
}
org.springframework.web.context.request.async.CallableInterceptorChain
public void applyPreProcess(NativeWebRequest request, Callable<?> task)
{
    for (CallableProcessingInterceptor interceptor: this.interceptors) {
        interceptor.preProcess(request, task);
        this.preProcessIndex++;
    }
}
org.springframework.web.context.request.async.CallableInterceptorChain
public void setTaskFuture(Future<?> taskFuture)
{
    this.taskFuture = taskFuture;
}
org.springframework.web.context.request.async.CallableInterceptorChain
volatile Future<?> taskFuture
org.springframework.web.context.request.async.CallableInterceptorChain
public void triggerAfterCompletion(NativeWebRequest request, Callable<?> task)
{
    for (int i = this.interceptors.size() - 1; i >= 0; i--) {
        try {
            this.interceptors.get(i).afterCompletion(request, task);
        } catch (Throwable ex) {
            if (logger.isTraceEnabled()) {
                logger.trace("Ignoring failure in afterCompletion method", ex);
            } 
        }
    }
}
org.springframework.web.context.request.async.CallableInterceptorChain
public Object triggerAfterError(NativeWebRequest request, Callable<?> task, Throwable throwable)
{
    cancelTask();
    for (CallableProcessingInterceptor interceptor: this.interceptors) {
        try {
            Object result = interceptor.handleError(request, task, throwable);
            if (result == CallableProcessingInterceptor.RESPONSE_HANDLED) {
                break;
            } else if (result != CallableProcessingInterceptor.RESULT_NONE) {
                return result;
            } 
        } catch (Throwable ex) {
            return ex;
        }
    }
    return CallableProcessingInterceptor.RESULT_NONE;
}
org.springframework.web.context.request.async.CallableInterceptorChain
public Object triggerAfterTimeout(NativeWebRequest request, Callable<?> task)
{
    cancelTask();
    for (CallableProcessingInterceptor interceptor: this.interceptors) {
        try {
            Object result = interceptor.handleTimeout(request, task);
            if (result == CallableProcessingInterceptor.RESPONSE_HANDLED) {
                break;
            } else if (result != CallableProcessingInterceptor.RESULT_NONE) {
                return result;
            } 
        } catch (Throwable ex) {
            return ex;
        }
    }
    return CallableProcessingInterceptor.RESULT_NONE;
}
 CallableProcessingInterceptor
 CallableProcessingInterceptorAdapter
 implements CallableProcessingInterceptor
org.springframework.web.context.request.async.CallableProcessingInterceptorAdapter
<T>@Override public void afterCompletion(NativeWebRequest request, Callable<T> task)
{
}
org.springframework.web.context.request.async.CallableProcessingInterceptorAdapter
<T>@Override public void beforeConcurrentHandling(NativeWebRequest request, Callable<T> task)
{
}
org.springframework.web.context.request.async.CallableProcessingInterceptorAdapter
<T>@Override public Object handleError(NativeWebRequest request, Callable<T> task, Throwable t)
{
    return RESULT_NONE;
}
org.springframework.web.context.request.async.CallableProcessingInterceptorAdapter
<T>@Override public Object handleTimeout(NativeWebRequest request, Callable<T> task)
{
    return RESULT_NONE;
}
org.springframework.web.context.request.async.CallableProcessingInterceptorAdapter
<T>@Override public void postProcess(NativeWebRequest request, Callable<T> task, Object concurrentResult)
{
}
org.springframework.web.context.request.async.CallableProcessingInterceptorAdapter
<T>@Override public void preProcess(NativeWebRequest request, Callable<T> task)
{
}
 DeferredResult<T>
org.springframework.web.context.request.async.DeferredResult
public DeferredResult DeferredResult()
{
    this(null, () -> RESULT_NONE);
}
org.springframework.web.context.request.async.DeferredResult
public DeferredResult DeferredResult(Long timeoutValue)
{
    this(timeoutValue, () -> RESULT_NONE);
}
org.springframework.web.context.request.async.DeferredResult
public DeferredResult DeferredResult(@Nullable Long timeoutValue, Object timeoutResult)
{
    this.timeoutValue = timeoutValue;
    this.timeoutResult = () -> timeoutResult;
}
org.springframework.web.context.request.async.DeferredResult
public DeferredResult DeferredResult(@Nullable Long timeoutValue, Supplier<?> timeoutResult)
{
    this.timeoutValue = timeoutValue;
    this.timeoutResult = timeoutResult;
}
 DeferredResultHandler
org.springframework.web.context.request.async.DeferredResult
volatile boolean expired
org.springframework.web.context.request.async.DeferredResult
@Nullable public Object getResult()
{
    Object resultToCheck = this.result;
    return (resultToCheck != RESULT_NONE ? resultToCheck : null);
}
org.springframework.web.context.request.async.DeferredResult
public boolean hasResult()
{
    return (this.result != RESULT_NONE);
}
org.springframework.web.context.request.async.DeferredResult
public final boolean isSetOrExpired()
{
    return (this.result != RESULT_NONE || this.expired);
}
org.springframework.web.context.request.async.DeferredResult
public void onCompletion(Runnable callback)
{
    this.completionCallback = callback;
}
org.springframework.web.context.request.async.DeferredResult
public void onError(Consumer<Throwable> callback)
{
    this.errorCallback = callback;
}
org.springframework.web.context.request.async.DeferredResult
public void onTimeout(Runnable callback)
{
    this.timeoutCallback = callback;
}
org.springframework.web.context.request.async.DeferredResult
volatile Object result
org.springframework.web.context.request.async.DeferredResult
public boolean setErrorResult(Object result)
{
    return setResultInternal(result);
}
org.springframework.web.context.request.async.DeferredResult
public boolean setResult(T result)
{
    return setResultInternal(result);
}
org.springframework.web.context.request.async.DeferredResult
public final void setResultHandler(DeferredResultHandler resultHandler)
{
    Assert.notNull(resultHandler, "DeferredResultHandler is required");
    if (this.expired) {
        return ;
    } 
    Object resultToHandle;
    synchronized(this) {
        if (this.expired) {
            return ;
        } 
        resultToHandle = this.result;
        if (resultToHandle == RESULT_NONE) {
            this.resultHandler = resultHandler;
            return ;
        } 
    }
    try {
        resultHandler.handleResult(resultToHandle);
    } catch (Throwable ex) {
        logger.debug("Failed to process async result", ex);
    }
}
 DeferredResultInterceptorChain
org.springframework.web.context.request.async.DeferredResultInterceptorChain
public DeferredResultInterceptorChain DeferredResultInterceptorChain(List<DeferredResultProcessingInterceptor> interceptors)
{
    this.interceptors = interceptors;
}
org.springframework.web.context.request.async.DeferredResultInterceptorChain
public void applyBeforeConcurrentHandling(NativeWebRequest request, DeferredResult<?> deferredResult)
{
    for (DeferredResultProcessingInterceptor interceptor: this.interceptors) {
        interceptor.beforeConcurrentHandling(request, deferredResult);
    }
}
org.springframework.web.context.request.async.DeferredResultInterceptorChain
public Object applyPostProcess(NativeWebRequest request, DeferredResult<?> deferredResult, Object concurrentResult)
{
    try {
        for (int i = this.preProcessingIndex; i >= 0; i--) {
            this.interceptors.get(i).postProcess(request, deferredResult, concurrentResult);
        }
    } catch (Throwable ex) {
        return ex;
    }
    return concurrentResult;
}
org.springframework.web.context.request.async.DeferredResultInterceptorChain
public void applyPreProcess(NativeWebRequest request, DeferredResult<?> deferredResult)
{
    for (DeferredResultProcessingInterceptor interceptor: this.interceptors) {
        interceptor.preProcess(request, deferredResult);
        this.preProcessingIndex++;
    }
}
org.springframework.web.context.request.async.DeferredResultInterceptorChain
public void triggerAfterCompletion(NativeWebRequest request, DeferredResult<?> deferredResult)
{
    for (int i = this.preProcessingIndex; i >= 0; i--) {
        try {
            this.interceptors.get(i).afterCompletion(request, deferredResult);
        } catch (Throwable ex) {
            logger.trace("Ignoring failure in afterCompletion method", ex);
        }
    }
}
org.springframework.web.context.request.async.DeferredResultInterceptorChain
public boolean triggerAfterError(NativeWebRequest request, DeferredResult<?> deferredResult, Throwable ex)
{
    for (DeferredResultProcessingInterceptor interceptor: this.interceptors) {
        if (deferredResult.isSetOrExpired()) {
            return false;
        } 
        if (!interceptor.handleError(request, deferredResult, ex)) {
            return false;
        } 
    }
    return true;
}
org.springframework.web.context.request.async.DeferredResultInterceptorChain
public void triggerAfterTimeout(NativeWebRequest request, DeferredResult<?> deferredResult)
{
    for (DeferredResultProcessingInterceptor interceptor: this.interceptors) {
        if (deferredResult.isSetOrExpired()) {
            return ;
        } 
        if (!interceptor.handleTimeout(request, deferredResult)) {
            break;
        } 
    }
}
 DeferredResultProcessingInterceptor
 DeferredResultProcessingInterceptorAdapter
 implements DeferredResultProcessingInterceptor
org.springframework.web.context.request.async.DeferredResultProcessingInterceptorAdapter
<T>@Override public void afterCompletion(NativeWebRequest request, DeferredResult<T> deferredResult)
{
}
org.springframework.web.context.request.async.DeferredResultProcessingInterceptorAdapter
<T>@Override public void beforeConcurrentHandling(NativeWebRequest request, DeferredResult<T> deferredResult)
{
}
org.springframework.web.context.request.async.DeferredResultProcessingInterceptorAdapter
<T>@Override public boolean handleError(NativeWebRequest request, DeferredResult<T> deferredResult, Throwable t)
{
    return true;
}
org.springframework.web.context.request.async.DeferredResultProcessingInterceptorAdapter
<T>@Override public boolean handleTimeout(NativeWebRequest request, DeferredResult<T> deferredResult)
{
    return true;
}
org.springframework.web.context.request.async.DeferredResultProcessingInterceptorAdapter
<T>@Override public void postProcess(NativeWebRequest request, DeferredResult<T> deferredResult, Object concurrentResult)
{
}
org.springframework.web.context.request.async.DeferredResultProcessingInterceptorAdapter
<T>@Override public void preProcess(NativeWebRequest request, DeferredResult<T> deferredResult)
{
}
 StandardServletAsyncWebRequest
 extends ServletWebRequest implements AsyncWebRequest, AsyncListener
org.springframework.web.context.request.async.StandardServletAsyncWebRequest
public StandardServletAsyncWebRequest StandardServletAsyncWebRequest(HttpServletRequest request, HttpServletResponse response)
{
    super(request, response);
}
org.springframework.web.context.request.async.StandardServletAsyncWebRequest
@Override public void addCompletionHandler(Runnable runnable)
{
    this.completionHandlers.add(runnable);
}
org.springframework.web.context.request.async.StandardServletAsyncWebRequest
@Override public void addErrorHandler(Consumer<Throwable> exceptionHandler)
{
    this.exceptionHandlers.add(exceptionHandler);
}
org.springframework.web.context.request.async.StandardServletAsyncWebRequest
@Override public void addTimeoutHandler(Runnable timeoutHandler)
{
    this.timeoutHandlers.add(timeoutHandler);
}
org.springframework.web.context.request.async.StandardServletAsyncWebRequest
@Override public void dispatch()
{
    Assert.notNull(this.asyncContext, "Cannot dispatch without an AsyncContext");
    this.asyncContext.dispatch();
}
org.springframework.web.context.request.async.StandardServletAsyncWebRequest
@Override public boolean isAsyncComplete()
{
    return this.asyncCompleted.get();
}
org.springframework.web.context.request.async.StandardServletAsyncWebRequest
@Override public boolean isAsyncStarted()
{
    return (this.asyncContext != null && getRequest().isAsyncStarted());
}
org.springframework.web.context.request.async.StandardServletAsyncWebRequest
@Override public void onComplete(AsyncEvent event)
{
    this.completionHandlers.forEach(Runnable::run);
    this.asyncContext = null;
    this.asyncCompleted.set(true);
}
org.springframework.web.context.request.async.StandardServletAsyncWebRequest
@Override public void onError(AsyncEvent event)
{
    this.exceptionHandlers.forEach(consumer -> consumer.accept(event.getThrowable()));
}
org.springframework.web.context.request.async.StandardServletAsyncWebRequest
@Override public void onStartAsync(AsyncEvent event)
{
}
org.springframework.web.context.request.async.StandardServletAsyncWebRequest
@Override public void onTimeout(AsyncEvent event)
{
    this.timeoutHandlers.forEach(Runnable::run);
}
org.springframework.web.context.request.async.StandardServletAsyncWebRequest
@Override public void setTimeout(Long timeout)
{
    Assert.state(!isAsyncStarted(), "Cannot change the timeout with concurrent handling in progress");
    this.timeout = timeout;
}
 TimeoutCallableProcessingInterceptor
 implements CallableProcessingInterceptor
org.springframework.web.context.request.async.TimeoutCallableProcessingInterceptor
<T>@Override public Object handleTimeout(NativeWebRequest request, Callable<T> task)
{
    return new AsyncRequestTimeoutException();
}
 TimeoutDeferredResultProcessingInterceptor
 implements DeferredResultProcessingInterceptor
org.springframework.web.context.request.async.TimeoutDeferredResultProcessingInterceptor
<T>@Override public boolean handleTimeout(NativeWebRequest request, DeferredResult<T> result)
{
    result.setErrorResult(new AsyncRequestTimeoutException());
    return false;
}
 WebAsyncManager
org.springframework.web.context.request.async.WebAsyncManager
public void clearConcurrentResult()
{
    synchronized(WebAsyncManager.this) {
        this.concurrentResult = RESULT_NONE;
        this.concurrentResultContext = null;
    }
}
org.springframework.web.context.request.async.WebAsyncManager
volatile Object concurrentResult
org.springframework.web.context.request.async.WebAsyncManager
volatile Object[] concurrentResultContext
org.springframework.web.context.request.async.WebAsyncManager
@Nullable public CallableProcessingInterceptor getCallableInterceptor(Object key)
{
    return this.callableInterceptors.get(key);
}
org.springframework.web.context.request.async.WebAsyncManager
public Object getConcurrentResult()
{
    return this.concurrentResult;
}
org.springframework.web.context.request.async.WebAsyncManager
public Object[] getConcurrentResultContext()
{
    return this.concurrentResultContext;
}
org.springframework.web.context.request.async.WebAsyncManager
@Nullable public DeferredResultProcessingInterceptor getDeferredResultInterceptor(Object key)
{
    return this.deferredResultInterceptors.get(key);
}
org.springframework.web.context.request.async.WebAsyncManager
public boolean hasConcurrentResult()
{
    return (this.concurrentResult != RESULT_NONE);
}
org.springframework.web.context.request.async.WebAsyncManager
public boolean isConcurrentHandlingStarted()
{
    return (this.asyncWebRequest != null && this.asyncWebRequest.isAsyncStarted());
}
org.springframework.web.context.request.async.WebAsyncManager
public void registerCallableInterceptor(Object key, CallableProcessingInterceptor interceptor)
{
    Assert.notNull(key, "Key is required");
    Assert.notNull(interceptor, "CallableProcessingInterceptor  is required");
    this.callableInterceptors.put(key, interceptor);
}
org.springframework.web.context.request.async.WebAsyncManager
public void registerDeferredResultInterceptor(Object key, DeferredResultProcessingInterceptor interceptor)
{
    Assert.notNull(key, "Key is required");
    Assert.notNull(interceptor, "DeferredResultProcessingInterceptor is required");
    this.deferredResultInterceptors.put(key, interceptor);
}
org.springframework.web.context.request.async.WebAsyncManager
public void setTaskExecutor(AsyncTaskExecutor taskExecutor)
{
    this.taskExecutor = taskExecutor;
}
org.springframework.web.context.request.async.WebAsyncManager
@SuppressWarnings({"rawtypes","unchecked"}) public void startCallableProcessing(Callable<?> callable, Object... processingContext)
{
    Assert.notNull(callable, "Callable must not be null");
    startCallableProcessing(new WebAsyncTask(callable), processingContext);
}
org.springframework.web.context.request.async.WebAsyncManager
public void startCallableProcessing(final WebAsyncTask<?> webAsyncTask, Object... processingContext)
{
    Assert.notNull(webAsyncTask, "WebAsyncTask must not be null");
    Assert.state(this.asyncWebRequest != null, "AsyncWebRequest must not be null");
    Long timeout = webAsyncTask.getTimeout();
    if (timeout != null) {
        this.asyncWebRequest.setTimeout(timeout);
    } 
    AsyncTaskExecutor executor = webAsyncTask.getExecutor();
    if (executor != null) {
        this.taskExecutor = executor;
    } else {
        logExecutorWarning();
    }
    List<CallableProcessingInterceptor> interceptors = new ArrayList<>();
    interceptors.add(webAsyncTask.getInterceptor());
    interceptors.addAll(this.callableInterceptors.values());
    interceptors.add(timeoutCallableInterceptor);
    final Callable<?> callable = webAsyncTask.getCallable();
    final CallableInterceptorChain interceptorChain = new CallableInterceptorChain(interceptors);
    this.asyncWebRequest.addTimeoutHandler(() -> {
        if (logger.isDebugEnabled()) {
            logger.debug("Async request timeout for " + formatRequestUri());
        } 
        Object result = interceptorChain.triggerAfterTimeout(this.asyncWebRequest, callable);
        if (result != CallableProcessingInterceptor.RESULT_NONE) {
            setConcurrentResultAndDispatch(result);
        } 
    });
    this.asyncWebRequest.addErrorHandler(ex -> {
        if (logger.isDebugEnabled()) {
            logger.debug("Async request error for " + formatRequestUri() + ": " + ex);
        } 
        Object result = interceptorChain.triggerAfterError(this.asyncWebRequest, callable, ex);
        result = (result != CallableProcessingInterceptor.RESULT_NONE ? result : ex);
        setConcurrentResultAndDispatch(result);
    });
    this.asyncWebRequest.addCompletionHandler(() -> interceptorChain.triggerAfterCompletion(this.asyncWebRequest, callable));
    interceptorChain.applyBeforeConcurrentHandling(this.asyncWebRequest, callable);
    startAsyncProcessing(processingContext);
    try {
        Future<?> future = this.taskExecutor.submit(() -> {
            Object result = null;
            try {
                interceptorChain.applyPreProcess(this.asyncWebRequest, callable);
                result = callable.call();
            } catch (Throwable ex) {
                result = ex;
            } finally {
                result = interceptorChain.applyPostProcess(this.asyncWebRequest, callable, result);
            }
            setConcurrentResultAndDispatch(result);
        });
        interceptorChain.setTaskFuture(future);
    } catch (RejectedExecutionException ex) {
        Object result = interceptorChain.applyPostProcess(this.asyncWebRequest, callable, ex);
        setConcurrentResultAndDispatch(result);
        throw ex;
    }
}
org.springframework.web.context.request.async.WebAsyncManager
public void startDeferredResultProcessing(final DeferredResult<?> deferredResult, Object... processingContext)
{
    Assert.notNull(deferredResult, "DeferredResult must not be null");
    Assert.state(this.asyncWebRequest != null, "AsyncWebRequest must not be null");
    Long timeout = deferredResult.getTimeoutValue();
    if (timeout != null) {
        this.asyncWebRequest.setTimeout(timeout);
    } 
    List<DeferredResultProcessingInterceptor> interceptors = new ArrayList<>();
    interceptors.add(deferredResult.getInterceptor());
    interceptors.addAll(this.deferredResultInterceptors.values());
    interceptors.add(timeoutDeferredResultInterceptor);
    final DeferredResultInterceptorChain interceptorChain = new DeferredResultInterceptorChain(interceptors);
    this.asyncWebRequest.addTimeoutHandler(() -> {
        try {
            interceptorChain.triggerAfterTimeout(this.asyncWebRequest, deferredResult);
        } catch (Throwable ex) {
            setConcurrentResultAndDispatch(ex);
        }
    });
    this.asyncWebRequest.addErrorHandler(ex -> {
        try {
            if (!interceptorChain.triggerAfterError(this.asyncWebRequest, deferredResult, ex)) {
                return ;
            } 
            deferredResult.setErrorResult(ex);
        } catch (Throwable interceptorEx) {
            setConcurrentResultAndDispatch(interceptorEx);
        }
    });
    this.asyncWebRequest.addCompletionHandler(() -> interceptorChain.triggerAfterCompletion(this.asyncWebRequest, deferredResult));
    interceptorChain.applyBeforeConcurrentHandling(this.asyncWebRequest, deferredResult);
    startAsyncProcessing(processingContext);
    try {
        interceptorChain.applyPreProcess(this.asyncWebRequest, deferredResult);
        deferredResult.setResultHandler(result -> {
            result = interceptorChain.applyPostProcess(this.asyncWebRequest, deferredResult, result);
            setConcurrentResultAndDispatch(result);
        });
    } catch (Throwable ex) {
        setConcurrentResultAndDispatch(ex);
    }
}
 WebAsyncTask<V>
 implements BeanFactoryAware
org.springframework.web.context.request.async.WebAsyncTask
public WebAsyncTask WebAsyncTask(Callable<V> callable)
{
    Assert.notNull(callable, "Callable must not be null");
    this.callable = callable;
}
org.springframework.web.context.request.async.WebAsyncTask
public WebAsyncTask WebAsyncTask(long timeout, Callable<V> callable)
{
    this(callable);
    this.timeout = timeout;
}
org.springframework.web.context.request.async.WebAsyncTask
public WebAsyncTask WebAsyncTask(@Nullable Long timeout, String executorName, Callable<V> callable)
{
    this(callable);
    Assert.notNull(executorName, "Executor name must not be null");
    this.executorName = executorName;
    this.timeout = timeout;
}
org.springframework.web.context.request.async.WebAsyncTask
public WebAsyncTask WebAsyncTask(@Nullable Long timeout, AsyncTaskExecutor executor, Callable<V> callable)
{
    this(callable);
    Assert.notNull(executor, "Executor must not be null");
    this.executor = executor;
    this.timeout = timeout;
}
org.springframework.web.context.request.async.WebAsyncTask
public Callable<?> getCallable()
{
    return this.callable;
}
org.springframework.web.context.request.async.WebAsyncTask
@Nullable public Long getTimeout()
{
    return this.timeout;
}
org.springframework.web.context.request.async.WebAsyncTask
public void onCompletion(Runnable callback)
{
    this.completionCallback = callback;
}
org.springframework.web.context.request.async.WebAsyncTask
public void onError(Callable<V> callback)
{
    this.errorCallback = callback;
}
org.springframework.web.context.request.async.WebAsyncTask
public void onTimeout(Callable<V> callback)
{
    this.timeoutCallback = callback;
}
org.springframework.web.context.request.async.WebAsyncTask
@Override public void setBeanFactory(BeanFactory beanFactory)
{
    this.beanFactory = beanFactory;
}
 WebAsyncUtils
org.springframework.web.context.request.async.WebAsyncUtils
public static final String WEB_ASYNC_MANAGER_ATTRIBUTE
org.springframework.web.context.request.async.WebAsyncUtils
public static AsyncWebRequest createAsyncWebRequest(HttpServletRequest request, HttpServletResponse response)
{
    return new StandardServletAsyncWebRequest(request, response);
}
 AbstractRefreshableWebApplicationContext
 extends AbstractRefreshableConfigApplicationContext implements ConfigurableWebApplicationContext, ThemeSource
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext
public AbstractRefreshableWebApplicationContext AbstractRefreshableWebApplicationContext()
{
    setDisplayName("Root WebApplicationContext");
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext
@Override protected ConfigurableEnvironment createEnvironment()
{
    return new StandardServletEnvironment();
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext
@Override public String getApplicationName()
{
    return (this.servletContext != null ? this.servletContext.getContextPath() : "");
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext
@Override public String[] getConfigLocations()
{
    return super.getConfigLocations();
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext
@Override @Nullable public String getNamespace()
{
    return this.namespace;
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext
@Override protected Resource getResourceByPath(String path)
{
    Assert.state(this.servletContext != null, "No ServletContext available");
    return new ServletContextResource(this.servletContext, path);
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext
@Override protected ResourcePatternResolver getResourcePatternResolver()
{
    return new ServletContextResourcePatternResolver(this);
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext
@Override @Nullable public ServletConfig getServletConfig()
{
    return this.servletConfig;
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext
@Override @Nullable public ServletContext getServletContext()
{
    return this.servletContext;
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext
@Override @Nullable public Theme getTheme(String themeName)
{
    Assert.state(this.themeSource != null, "No ThemeSource available");
    return this.themeSource.getTheme(themeName);
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext
@Override protected void onRefresh()
{
    this.themeSource = UiApplicationContextUtils.initThemeSource(this);
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext
@Override public void setNamespace(@Nullable String namespace)
{
    this.namespace = namespace;
    if (namespace != null) {
        setDisplayName("WebApplicationContext for namespace '" + namespace + "'");
    } 
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext
@Override public void setServletConfig(@Nullable ServletConfig servletConfig)
{
    this.servletConfig = servletConfig;
    if (servletConfig != null && this.servletContext == null) {
        setServletContext(servletConfig.getServletContext());
    } 
}
org.springframework.web.context.support.AbstractRefreshableWebApplicationContext
@Override public void setServletContext(@Nullable ServletContext servletContext)
{
    this.servletContext = servletContext;
}
 AnnotationConfigWebApplicationContext
 extends AbstractRefreshableWebApplicationContext implements AnnotationConfigRegistry
org.springframework.web.context.support.AnnotationConfigWebApplicationContext
protected AnnotatedBeanDefinitionReader getAnnotatedBeanDefinitionReader(DefaultListableBeanFactory beanFactory)
{
    return new AnnotatedBeanDefinitionReader(beanFactory, getEnvironment());
}
org.springframework.web.context.support.AnnotationConfigWebApplicationContext
@Nullable protected BeanNameGenerator getBeanNameGenerator()
{
    return this.beanNameGenerator;
}
org.springframework.web.context.support.AnnotationConfigWebApplicationContext
protected ClassPathBeanDefinitionScanner getClassPathBeanDefinitionScanner(DefaultListableBeanFactory beanFactory)
{
    return new ClassPathBeanDefinitionScanner(beanFactory, true, getEnvironment());
}
org.springframework.web.context.support.AnnotationConfigWebApplicationContext
@Nullable protected ScopeMetadataResolver getScopeMetadataResolver()
{
    return this.scopeMetadataResolver;
}
org.springframework.web.context.support.AnnotationConfigWebApplicationContext
@Override protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
{
    AnnotatedBeanDefinitionReader reader = getAnnotatedBeanDefinitionReader(beanFactory);
    ClassPathBeanDefinitionScanner scanner = getClassPathBeanDefinitionScanner(beanFactory);
    BeanNameGenerator beanNameGenerator = getBeanNameGenerator();
    if (beanNameGenerator != null) {
        reader.setBeanNameGenerator(beanNameGenerator);
        scanner.setBeanNameGenerator(beanNameGenerator);
        beanFactory.registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator);
    } 
    ScopeMetadataResolver scopeMetadataResolver = getScopeMetadataResolver();
    if (scopeMetadataResolver != null) {
        reader.setScopeMetadataResolver(scopeMetadataResolver);
        scanner.setScopeMetadataResolver(scopeMetadataResolver);
    } 
    if (!this.componentClasses.isEmpty()) {
        if (logger.isDebugEnabled()) {
            logger.debug("Registering component classes: [" + StringUtils.collectionToCommaDelimitedString(this.componentClasses) + "]");
        } 
        reader.register(ClassUtils.toClassArray(this.componentClasses));
    } 
    if (!this.basePackages.isEmpty()) {
        if (logger.isDebugEnabled()) {
            logger.debug("Scanning base packages: [" + StringUtils.collectionToCommaDelimitedString(this.basePackages) + "]");
        } 
        scanner.scan(StringUtils.toStringArray(this.basePackages));
    } 
    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
        for (String configLocation: configLocations) {
            try {
                Class<?> clazz = ClassUtils.forName(configLocation, getClassLoader());
                if (logger.isTraceEnabled()) {
                    logger.trace("Registering [" + configLocation + "]");
                } 
                reader.register(clazz);
            } catch (ClassNotFoundException ex) {
                if (logger.isTraceEnabled()) {
                    logger.trace("Could not load class for config location [" + configLocation + "] - trying package scan. " + ex);
                } 
                int count = scanner.scan(configLocation);
                if (count == 0 && logger.isDebugEnabled()) {
                    logger.debug("No component classes found for specified class/package [" + configLocation + "]");
                } 
            }
        }
    } 
}
org.springframework.web.context.support.AnnotationConfigWebApplicationContext
@Override public void register(Class<?>... componentClasses)
{
    Assert.notEmpty(componentClasses, "At least one component class must be specified");
    Collections.addAll(this.componentClasses, componentClasses);
}
org.springframework.web.context.support.AnnotationConfigWebApplicationContext
@Override public void scan(String... basePackages)
{
    Assert.notEmpty(basePackages, "At least one base package must be specified");
    Collections.addAll(this.basePackages, basePackages);
}
org.springframework.web.context.support.AnnotationConfigWebApplicationContext
public void setBeanNameGenerator(@Nullable BeanNameGenerator beanNameGenerator)
{
    this.beanNameGenerator = beanNameGenerator;
}
org.springframework.web.context.support.AnnotationConfigWebApplicationContext
public void setScopeMetadataResolver(@Nullable ScopeMetadataResolver scopeMetadataResolver)
{
    this.scopeMetadataResolver = scopeMetadataResolver;
}
 ContextExposingHttpServletRequest
 extends HttpServletRequestWrapper
org.springframework.web.context.support.ContextExposingHttpServletRequest
public ContextExposingHttpServletRequest ContextExposingHttpServletRequest(HttpServletRequest originalRequest, WebApplicationContext context)
{
    this(originalRequest, context, null);
}
org.springframework.web.context.support.ContextExposingHttpServletRequest
public ContextExposingHttpServletRequest ContextExposingHttpServletRequest(HttpServletRequest originalRequest, WebApplicationContext context, @Nullable Set<String> exposedContextBeanNames)
{
    super(originalRequest);
    Assert.notNull(context, "WebApplicationContext must not be null");
    this.webApplicationContext = context;
    this.exposedContextBeanNames = exposedContextBeanNames;
}
org.springframework.web.context.support.ContextExposingHttpServletRequest
public final WebApplicationContext getWebApplicationContext()
{
    return this.webApplicationContext;
}
org.springframework.web.context.support.ContextExposingHttpServletRequest
@Override public void setAttribute(String name, Object value)
{
    super.setAttribute(name, value);
    if (this.explicitAttributes == null) {
        this.explicitAttributes = new HashSet<>(8);
    } 
    this.explicitAttributes.add(name);
}
 GenericWebApplicationContext
 extends GenericApplicationContext implements ConfigurableWebApplicationContext, ThemeSource
org.springframework.web.context.support.GenericWebApplicationContext
public GenericWebApplicationContext GenericWebApplicationContext()
{
    super();
}
org.springframework.web.context.support.GenericWebApplicationContext
public GenericWebApplicationContext GenericWebApplicationContext(ServletContext servletContext)
{
    this.servletContext = servletContext;
}
org.springframework.web.context.support.GenericWebApplicationContext
public GenericWebApplicationContext GenericWebApplicationContext(DefaultListableBeanFactory beanFactory)
{
    super(beanFactory);
}
org.springframework.web.context.support.GenericWebApplicationContext
public GenericWebApplicationContext GenericWebApplicationContext(DefaultListableBeanFactory beanFactory, ServletContext servletContext)
{
    super(beanFactory);
    this.servletContext = servletContext;
}
org.springframework.web.context.support.GenericWebApplicationContext
@Override protected ConfigurableEnvironment createEnvironment()
{
    return new StandardServletEnvironment();
}
org.springframework.web.context.support.GenericWebApplicationContext
@Override public String getApplicationName()
{
    return (this.servletContext != null ? this.servletContext.getContextPath() : "");
}
org.springframework.web.context.support.GenericWebApplicationContext
@Override public String[] getConfigLocations()
{
    throw new UnsupportedOperationException("GenericWebApplicationContext does not support getConfigLocations()");
}
org.springframework.web.context.support.GenericWebApplicationContext
@Override @Nullable public String getNamespace()
{
    throw new UnsupportedOperationException("GenericWebApplicationContext does not support getNamespace()");
}
org.springframework.web.context.support.GenericWebApplicationContext
@Override protected Resource getResourceByPath(String path)
{
    Assert.state(this.servletContext != null, "No ServletContext available");
    return new ServletContextResource(this.servletContext, path);
}
org.springframework.web.context.support.GenericWebApplicationContext
@Override protected ResourcePatternResolver getResourcePatternResolver()
{
    return new ServletContextResourcePatternResolver(this);
}
org.springframework.web.context.support.GenericWebApplicationContext
@Override @Nullable public ServletConfig getServletConfig()
{
    throw new UnsupportedOperationException("GenericWebApplicationContext does not support getServletConfig()");
}
org.springframework.web.context.support.GenericWebApplicationContext
@Override @Nullable public ServletContext getServletContext()
{
    return this.servletContext;
}
org.springframework.web.context.support.GenericWebApplicationContext
@Override @Nullable public Theme getTheme(String themeName)
{
    Assert.state(this.themeSource != null, "No ThemeSource available");
    return this.themeSource.getTheme(themeName);
}
org.springframework.web.context.support.GenericWebApplicationContext
@Override protected void onRefresh()
{
    this.themeSource = UiApplicationContextUtils.initThemeSource(this);
}
org.springframework.web.context.support.GenericWebApplicationContext
@Override protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)
{
    if (this.servletContext != null) {
        beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext));
        beanFactory.ignoreDependencyInterface(ServletContextAware.class);
    } 
    WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
    WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext);
}
org.springframework.web.context.support.GenericWebApplicationContext
@Override public void setNamespace(@Nullable String namespace)
{
}
org.springframework.web.context.support.GenericWebApplicationContext
@Override public void setServletConfig(@Nullable ServletConfig servletConfig)
{
}
org.springframework.web.context.support.GenericWebApplicationContext
@Override public void setServletContext(@Nullable ServletContext servletContext)
{
    this.servletContext = servletContext;
}
 GroovyWebApplicationContext
 extends AbstractRefreshableWebApplicationContext implements GroovyObject
org.springframework.web.context.support.GroovyWebApplicationContext
public static final String DEFAULT_CONFIG_LOCATION
org.springframework.web.context.support.GroovyWebApplicationContext
public static final String DEFAULT_CONFIG_LOCATION_PREFIX
org.springframework.web.context.support.GroovyWebApplicationContext
public static final String DEFAULT_CONFIG_LOCATION_SUFFIX
org.springframework.web.context.support.GroovyWebApplicationContext
@Override protected String[] getDefaultConfigLocations()
{
    if (getNamespace() != null) {
        return new String[]{DEFAULT_CONFIG_LOCATION_PREFIX + getNamespace() + DEFAULT_CONFIG_LOCATION_SUFFIX};
    } else {
        return new String[]{DEFAULT_CONFIG_LOCATION};
    }
}
org.springframework.web.context.support.GroovyWebApplicationContext
@Override public MetaClass getMetaClass()
{
    return this.metaClass;
}
org.springframework.web.context.support.GroovyWebApplicationContext
@Override @Nullable public Object getProperty(String property)
{
    if (containsBean(property)) {
        return getBean(property);
    } else if (this.contextWrapper.isReadableProperty(property)) {
        return this.contextWrapper.getPropertyValue(property);
    } 
    throw new NoSuchBeanDefinitionException(property);
}
org.springframework.web.context.support.GroovyWebApplicationContext
protected void initBeanDefinitionReader(GroovyBeanDefinitionReader beanDefinitionReader)
{
}
org.springframework.web.context.support.GroovyWebApplicationContext
@Override public Object invokeMethod(String name, Object args)
{
    return this.metaClass.invokeMethod(this, name, args);
}
org.springframework.web.context.support.GroovyWebApplicationContext
protected void loadBeanDefinitions(GroovyBeanDefinitionReader reader)
{
    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
        for (String configLocation: configLocations) {
            reader.loadBeanDefinitions(configLocation);
        }
    } 
}
org.springframework.web.context.support.GroovyWebApplicationContext
@Override public void setMetaClass(MetaClass metaClass)
{
    this.metaClass = metaClass;
}
org.springframework.web.context.support.GroovyWebApplicationContext
@Override public void setProperty(String property, Object newValue)
{
    this.metaClass.setProperty(this, property, newValue);
}
 HttpRequestHandlerServlet
 extends HttpServlet
org.springframework.web.context.support.HttpRequestHandlerServlet
@Override protected void service(HttpServletRequest request, HttpServletResponse response)
{
    Assert.state(this.target != null, "No HttpRequestHandler available");
    LocaleContextHolder.setLocale(request.getLocale());
    try {
        this.target.handleRequest(request, response);
    } catch (HttpRequestMethodNotSupportedException ex) {
        String[] supportedMethods = ex.getSupportedMethods();
        if (supportedMethods != null) {
            response.setHeader("Allow", StringUtils.arrayToDelimitedString(supportedMethods, ", "));
        } 
        response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, ex.getMessage());
    } finally {
        LocaleContextHolder.resetLocaleContext();
    }
}
 LiveBeansViewServlet
 extends HttpServlet
org.springframework.web.context.support.LiveBeansViewServlet
protected LiveBeansView buildLiveBeansView()
{
    return new ServletContextLiveBeansView(getServletContext());
}
org.springframework.web.context.support.LiveBeansViewServlet
@Override public void init()
{
    this.liveBeansView = buildLiveBeansView();
}
 RequestHandledEvent
 extends ApplicationEvent
org.springframework.web.context.support.RequestHandledEvent
public RequestHandledEvent RequestHandledEvent(Object source, @Nullable String sessionId, @Nullable String userName, long processingTimeMillis)
{
    super(source);
    this.sessionId = sessionId;
    this.userName = userName;
    this.processingTimeMillis = processingTimeMillis;
}
org.springframework.web.context.support.RequestHandledEvent
public RequestHandledEvent RequestHandledEvent(Object source, @Nullable String sessionId, @Nullable String userName, long processingTimeMillis, @Nullable Throwable failureCause)
{
    this(source, sessionId, userName, processingTimeMillis);
    this.failureCause = failureCause;
}
org.springframework.web.context.support.RequestHandledEvent
@Nullable public Throwable getFailureCause()
{
    return this.failureCause;
}
org.springframework.web.context.support.RequestHandledEvent
public long getProcessingTimeMillis()
{
    return this.processingTimeMillis;
}
org.springframework.web.context.support.RequestHandledEvent
@Nullable public String getSessionId()
{
    return this.sessionId;
}
org.springframework.web.context.support.RequestHandledEvent
@Nullable public String getUserName()
{
    return this.userName;
}
org.springframework.web.context.support.RequestHandledEvent
@Override public String toString()
{
    return ("RequestHandledEvent: " + getDescription());
}
org.springframework.web.context.support.RequestHandledEvent
public boolean wasFailure()
{
    return (this.failureCause != null);
}
 ServletConfigPropertySource
 extends EnumerablePropertySource<ServletConfig>
org.springframework.web.context.support.ServletConfigPropertySource
public ServletConfigPropertySource ServletConfigPropertySource(String name, ServletConfig servletConfig)
{
    super(name, servletConfig);
}
org.springframework.web.context.support.ServletConfigPropertySource
@Override @Nullable public String getProperty(String name)
{
    return this.source.getInitParameter(name);
}
org.springframework.web.context.support.ServletConfigPropertySource
@Override public String[] getPropertyNames()
{
    return StringUtils.toStringArray(this.source.getInitParameterNames());
}
 ServletContextAttributeExporter
 implements ServletContextAware
org.springframework.web.context.support.ServletContextAttributeExporter
protected final Log logger
org.springframework.web.context.support.ServletContextAttributeExporter
public void setAttributes(Map<String, Object> attributes)
{
    this.attributes = attributes;
}
 ServletContextAttributeFactoryBean
 implements FactoryBean<Object>, ServletContextAware
org.springframework.web.context.support.ServletContextAttributeFactoryBean
@Override @Nullable public Object getObject()
{
    return this.attribute;
}
org.springframework.web.context.support.ServletContextAttributeFactoryBean
@Override public Class<?> getObjectType()
{
    return (this.attribute != null ? this.attribute.getClass() : null);
}
org.springframework.web.context.support.ServletContextAttributeFactoryBean
@Override public boolean isSingleton()
{
    return true;
}
org.springframework.web.context.support.ServletContextAttributeFactoryBean
public void setAttributeName(String attributeName)
{
    this.attributeName = attributeName;
}
org.springframework.web.context.support.ServletContextAttributeFactoryBean
@Override public void setServletContext(ServletContext servletContext)
{
    if (this.attributeName == null) {
        throw new IllegalArgumentException("Property 'attributeName' is required");
    } 
    this.attribute = servletContext.getAttribute(this.attributeName);
    if (this.attribute == null) {
        throw new IllegalStateException("No ServletContext attribute '" + this.attributeName + "' found");
    } 
}
 ServletContextAwareProcessor
 implements BeanPostProcessor
org.springframework.web.context.support.ServletContextAwareProcessor
protected ServletContextAwareProcessor ServletContextAwareProcessor()
{
}
org.springframework.web.context.support.ServletContextAwareProcessor
public ServletContextAwareProcessor ServletContextAwareProcessor(ServletContext servletContext)
{
    this(servletContext, null);
}
org.springframework.web.context.support.ServletContextAwareProcessor
public ServletContextAwareProcessor ServletContextAwareProcessor(ServletConfig servletConfig)
{
    this(null, servletConfig);
}
org.springframework.web.context.support.ServletContextAwareProcessor
public ServletContextAwareProcessor ServletContextAwareProcessor(@Nullable ServletContext servletContext, @Nullable ServletConfig servletConfig)
{
    this.servletContext = servletContext;
    this.servletConfig = servletConfig;
}
org.springframework.web.context.support.ServletContextAwareProcessor
@Nullable protected ServletConfig getServletConfig()
{
    return this.servletConfig;
}
org.springframework.web.context.support.ServletContextAwareProcessor
@Nullable protected ServletContext getServletContext()
{
    if (this.servletContext == null && getServletConfig() != null) {
        return getServletConfig().getServletContext();
    } 
    return this.servletContext;
}
org.springframework.web.context.support.ServletContextAwareProcessor
@Override public Object postProcessAfterInitialization(Object bean, String beanName)
{
    return bean;
}
org.springframework.web.context.support.ServletContextAwareProcessor
@Override public Object postProcessBeforeInitialization(Object bean, String beanName)
{
    if (getServletContext() != null && bean instanceof ServletContextAware) {
        ((ServletContextAware)bean).setServletContext(getServletContext());
    } 
    if (getServletConfig() != null && bean instanceof ServletConfigAware) {
        ((ServletConfigAware)bean).setServletConfig(getServletConfig());
    } 
    return bean;
}
 ServletContextLiveBeansView
 extends LiveBeansView
org.springframework.web.context.support.ServletContextLiveBeansView
public ServletContextLiveBeansView ServletContextLiveBeansView(ServletContext servletContext)
{
    Assert.notNull(servletContext, "ServletContext must not be null");
    this.servletContext = servletContext;
}
 ServletContextParameterFactoryBean
 implements FactoryBean<String>, ServletContextAware
org.springframework.web.context.support.ServletContextParameterFactoryBean
@Override @Nullable public String getObject()
{
    return this.paramValue;
}
org.springframework.web.context.support.ServletContextParameterFactoryBean
@Override public Class<String> getObjectType()
{
    return String.class;
}
org.springframework.web.context.support.ServletContextParameterFactoryBean
@Override public boolean isSingleton()
{
    return true;
}
org.springframework.web.context.support.ServletContextParameterFactoryBean
public void setInitParamName(String initParamName)
{
    this.initParamName = initParamName;
}
org.springframework.web.context.support.ServletContextParameterFactoryBean
@Override public void setServletContext(ServletContext servletContext)
{
    if (this.initParamName == null) {
        throw new IllegalArgumentException("initParamName is required");
    } 
    this.paramValue = servletContext.getInitParameter(this.initParamName);
    if (this.paramValue == null) {
        throw new IllegalStateException("No ServletContext init parameter '" + this.initParamName + "' found");
    } 
}
 ServletContextPropertySource
 extends EnumerablePropertySource<ServletContext>
org.springframework.web.context.support.ServletContextPropertySource
public ServletContextPropertySource ServletContextPropertySource(String name, ServletContext servletContext)
{
    super(name, servletContext);
}
org.springframework.web.context.support.ServletContextPropertySource
@Override @Nullable public String getProperty(String name)
{
    return this.source.getInitParameter(name);
}
org.springframework.web.context.support.ServletContextPropertySource
@Override public String[] getPropertyNames()
{
    return StringUtils.toStringArray(this.source.getInitParameterNames());
}
 ServletContextResource
 extends AbstractFileResolvingResource implements ContextResource
org.springframework.web.context.support.ServletContextResource
@Override public Resource createRelative(String relativePath)
{
    String pathToUse = StringUtils.applyRelativePath(this.path, relativePath);
    return new ServletContextResource(this.servletContext, pathToUse);
}
org.springframework.web.context.support.ServletContextResource
@Override public boolean equals(@Nullable Object other)
{
    if (this == other) {
        return true;
    } 
    if (!(other instanceof ServletContextResource)) {
        return false;
    } 
    ServletContextResource otherRes = (ServletContextResource)other;
    return (this.servletContext.equals(otherRes.servletContext) && this.path.equals(otherRes.path));
}
org.springframework.web.context.support.ServletContextResource
@Override public boolean exists()
{
    try {
        URL url = this.servletContext.getResource(this.path);
        return (url != null);
    } catch (MalformedURLException ex) {
        return false;
    }
}
org.springframework.web.context.support.ServletContextResource
@Override public String getDescription()
{
    return "ServletContext resource [" + this.path + "]";
}
org.springframework.web.context.support.ServletContextResource
@Override @Nullable public String getFilename()
{
    return StringUtils.getFilename(this.path);
}
org.springframework.web.context.support.ServletContextResource
@Override public InputStream getInputStream()
{
    InputStream is = this.servletContext.getResourceAsStream(this.path);
    if (is == null) {
        throw new FileNotFoundException("Could not open " + getDescription());
    } 
    return is;
}
org.springframework.web.context.support.ServletContextResource
public final String getPath()
{
    return this.path;
}
org.springframework.web.context.support.ServletContextResource
@Override public String getPathWithinContext()
{
    return this.path;
}
org.springframework.web.context.support.ServletContextResource
public final ServletContext getServletContext()
{
    return this.servletContext;
}
org.springframework.web.context.support.ServletContextResource
@Override public int hashCode()
{
    return this.path.hashCode();
}
org.springframework.web.context.support.ServletContextResource
@Override public boolean isFile()
{
    try {
        URL url = this.servletContext.getResource(this.path);
        if (url != null && ResourceUtils.isFileURL(url)) {
            return true;
        } else {
            return (this.servletContext.getRealPath(this.path) != null);
        }
    } catch (MalformedURLException ex) {
        return false;
    }
}
org.springframework.web.context.support.ServletContextResource
@Override public boolean isReadable()
{
    InputStream is = this.servletContext.getResourceAsStream(this.path);
    if (is != null) {
        try {
            is.close();
        } catch (IOException ex) {
        }
        return true;
    } else {
        return false;
    }
}
 ServletContextResourceLoader
 extends DefaultResourceLoader
org.springframework.web.context.support.ServletContextResourceLoader
public ServletContextResourceLoader ServletContextResourceLoader(ServletContext servletContext)
{
    this.servletContext = servletContext;
}
org.springframework.web.context.support.ServletContextResourceLoader
@Override protected Resource getResourceByPath(String path)
{
    return new ServletContextResource(this.servletContext, path);
}
 ServletContextResourcePatternResolver
 extends PathMatchingResourcePatternResolver
org.springframework.web.context.support.ServletContextResourcePatternResolver
public ServletContextResourcePatternResolver ServletContextResourcePatternResolver(ServletContext servletContext)
{
    super(new ServletContextResourceLoader(servletContext));
}
org.springframework.web.context.support.ServletContextResourcePatternResolver
public ServletContextResourcePatternResolver ServletContextResourcePatternResolver(ResourceLoader resourceLoader)
{
    super(resourceLoader);
}
org.springframework.web.context.support.ServletContextResourcePatternResolver
protected void doRetrieveMatchingServletContextResources(ServletContext servletContext, String fullPattern, String dir, Set<Resource> result)
{
    Set<String> candidates = servletContext.getResourcePaths(dir);
    if (candidates != null) {
        boolean dirDepthNotFixed = fullPattern.contains("**");
        int jarFileSep = fullPattern.indexOf(ResourceUtils.JAR_URL_SEPARATOR);
        String jarFilePath = null;
        String pathInJarFile = null;
        if (jarFileSep > 0 && jarFileSep + ResourceUtils.JAR_URL_SEPARATOR.length() < fullPattern.length()) {
            jarFilePath = fullPattern.substring(0, jarFileSep);
            pathInJarFile = fullPattern.substring(jarFileSep + ResourceUtils.JAR_URL_SEPARATOR.length());
        } 
        for (String currPath: candidates) {
            if (!currPath.startsWith(dir)) {
                int dirIndex = currPath.indexOf(dir);
                if (dirIndex != -1) {
                    currPath = currPath.substring(dirIndex);
                } 
            } 
            if (currPath.endsWith("/") && (dirDepthNotFixed || StringUtils.countOccurrencesOf(currPath, "/") <= StringUtils.countOccurrencesOf(fullPattern, "/"))) {
                doRetrieveMatchingServletContextResources(servletContext, fullPattern, currPath, result);
            } 
            if (jarFilePath != null && getPathMatcher().match(jarFilePath, currPath)) {
                String absoluteJarPath = servletContext.getRealPath(currPath);
                if (absoluteJarPath != null) {
                    doRetrieveMatchingJarEntries(absoluteJarPath, pathInJarFile, result);
                } 
            } 
            if (getPathMatcher().match(fullPattern, currPath)) {
                result.add(new ServletContextResource(servletContext, currPath));
            } 
        }
    } 
}
 ServletContextScope
 implements Scope, DisposableBean
org.springframework.web.context.support.ServletContextScope
public ServletContextScope ServletContextScope(ServletContext servletContext)
{
    Assert.notNull(servletContext, "ServletContext must not be null");
    this.servletContext = servletContext;
}
org.springframework.web.context.support.ServletContextScope
@Override public void destroy()
{
    synchronized(this.destructionCallbacks) {
        for (Runnable runnable: this.destructionCallbacks.values()) {
            runnable.run();
        }
        this.destructionCallbacks.clear();
    }
}
org.springframework.web.context.support.ServletContextScope
@Override public Object get(String name, ObjectFactory<?> objectFactory)
{
    Object scopedObject = this.servletContext.getAttribute(name);
    if (scopedObject == null) {
        scopedObject = objectFactory.getObject();
        this.servletContext.setAttribute(name, scopedObject);
    } 
    return scopedObject;
}
org.springframework.web.context.support.ServletContextScope
@Override @Nullable public String getConversationId()
{
    return null;
}
org.springframework.web.context.support.ServletContextScope
@Override public void registerDestructionCallback(String name, Runnable callback)
{
    synchronized(this.destructionCallbacks) {
        this.destructionCallbacks.put(name, callback);
    }
}
org.springframework.web.context.support.ServletContextScope
@Override @Nullable public Object remove(String name)
{
    Object scopedObject = this.servletContext.getAttribute(name);
    if (scopedObject != null) {
        synchronized(this.destructionCallbacks) {
            this.destructionCallbacks.remove(name);
        }
        this.servletContext.removeAttribute(name);
        return scopedObject;
    } else {
        return null;
    }
}
org.springframework.web.context.support.ServletContextScope
@Override @Nullable public Object resolveContextualObject(String key)
{
    return null;
}
 ServletRequestHandledEvent
 extends RequestHandledEvent
org.springframework.web.context.support.ServletRequestHandledEvent
public ServletRequestHandledEvent ServletRequestHandledEvent(Object source, String requestUrl, String clientAddress, String method, String servletName, @Nullable String sessionId, @Nullable String userName, long processingTimeMillis)
{
    super(source, sessionId, userName, processingTimeMillis);
    this.requestUrl = requestUrl;
    this.clientAddress = clientAddress;
    this.method = method;
    this.servletName = servletName;
    this.statusCode = -1;
}
org.springframework.web.context.support.ServletRequestHandledEvent
public ServletRequestHandledEvent ServletRequestHandledEvent(Object source, String requestUrl, String clientAddress, String method, String servletName, @Nullable String sessionId, @Nullable String userName, long processingTimeMillis, @Nullable Throwable failureCause)
{
    super(source, sessionId, userName, processingTimeMillis, failureCause);
    this.requestUrl = requestUrl;
    this.clientAddress = clientAddress;
    this.method = method;
    this.servletName = servletName;
    this.statusCode = -1;
}
org.springframework.web.context.support.ServletRequestHandledEvent
public ServletRequestHandledEvent ServletRequestHandledEvent(Object source, String requestUrl, String clientAddress, String method, String servletName, @Nullable String sessionId, @Nullable String userName, long processingTimeMillis, @Nullable Throwable failureCause, int statusCode)
{
    super(source, sessionId, userName, processingTimeMillis, failureCause);
    this.requestUrl = requestUrl;
    this.clientAddress = clientAddress;
    this.method = method;
    this.servletName = servletName;
    this.statusCode = statusCode;
}
org.springframework.web.context.support.ServletRequestHandledEvent
public String getClientAddress()
{
    return this.clientAddress;
}
org.springframework.web.context.support.ServletRequestHandledEvent
public String getMethod()
{
    return this.method;
}
org.springframework.web.context.support.ServletRequestHandledEvent
public String getRequestUrl()
{
    return this.requestUrl;
}
org.springframework.web.context.support.ServletRequestHandledEvent
public String getServletName()
{
    return this.servletName;
}
org.springframework.web.context.support.ServletRequestHandledEvent
public int getStatusCode()
{
    return this.statusCode;
}
org.springframework.web.context.support.ServletRequestHandledEvent
@Override public String toString()
{
    return "ServletRequestHandledEvent: " + getDescription();
}
 StandardServletEnvironment
 extends StandardEnvironment implements ConfigurableWebEnvironment
org.springframework.web.context.support.StandardServletEnvironment
public static final String JNDI_PROPERTY_SOURCE_NAME
org.springframework.web.context.support.StandardServletEnvironment
public static final String SERVLET_CONFIG_PROPERTY_SOURCE_NAME
org.springframework.web.context.support.StandardServletEnvironment
public static final String SERVLET_CONTEXT_PROPERTY_SOURCE_NAME
org.springframework.web.context.support.StandardServletEnvironment
@Override public void initPropertySources(@Nullable ServletContext servletContext, @Nullable ServletConfig servletConfig)
{
    WebApplicationContextUtils.initServletPropertySources(getPropertySources(), servletContext, servletConfig);
}
 StaticWebApplicationContext
 extends StaticApplicationContext implements ConfigurableWebApplicationContext, ThemeSource
org.springframework.web.context.support.StaticWebApplicationContext
public StaticWebApplicationContext StaticWebApplicationContext()
{
    setDisplayName("Root WebApplicationContext");
}
org.springframework.web.context.support.StaticWebApplicationContext
@Override protected ConfigurableEnvironment createEnvironment()
{
    return new StandardServletEnvironment();
}
org.springframework.web.context.support.StaticWebApplicationContext
@Override public String[] getConfigLocations()
{
    return null;
}
org.springframework.web.context.support.StaticWebApplicationContext
@Override @Nullable public String getNamespace()
{
    return this.namespace;
}
org.springframework.web.context.support.StaticWebApplicationContext
@Override protected Resource getResourceByPath(String path)
{
    Assert.state(this.servletContext != null, "No ServletContext available");
    return new ServletContextResource(this.servletContext, path);
}
org.springframework.web.context.support.StaticWebApplicationContext
@Override protected ResourcePatternResolver getResourcePatternResolver()
{
    return new ServletContextResourcePatternResolver(this);
}
org.springframework.web.context.support.StaticWebApplicationContext
@Override @Nullable public ServletConfig getServletConfig()
{
    return this.servletConfig;
}
org.springframework.web.context.support.StaticWebApplicationContext
@Override @Nullable public ServletContext getServletContext()
{
    return this.servletContext;
}
org.springframework.web.context.support.StaticWebApplicationContext
@Override @Nullable public Theme getTheme(String themeName)
{
    Assert.state(this.themeSource != null, "No ThemeSource available");
    return this.themeSource.getTheme(themeName);
}
org.springframework.web.context.support.StaticWebApplicationContext
@Override protected void initPropertySources()
{
    WebApplicationContextUtils.initServletPropertySources(getEnvironment().getPropertySources(), this.servletContext, this.servletConfig);
}
org.springframework.web.context.support.StaticWebApplicationContext
@Override protected void onRefresh()
{
    this.themeSource = UiApplicationContextUtils.initThemeSource(this);
}
org.springframework.web.context.support.StaticWebApplicationContext
@Override public void setConfigLocation(String configLocation)
{
    throw new UnsupportedOperationException("StaticWebApplicationContext does not support config locations");
}
org.springframework.web.context.support.StaticWebApplicationContext
@Override public void setConfigLocations(String... configLocations)
{
    throw new UnsupportedOperationException("StaticWebApplicationContext does not support config locations");
}
org.springframework.web.context.support.StaticWebApplicationContext
@Override public void setNamespace(@Nullable String namespace)
{
    this.namespace = namespace;
    if (namespace != null) {
        setDisplayName("WebApplicationContext for namespace '" + namespace + "'");
    } 
}
org.springframework.web.context.support.StaticWebApplicationContext
@Override public void setServletConfig(@Nullable ServletConfig servletConfig)
{
    this.servletConfig = servletConfig;
    if (servletConfig != null && this.servletContext == null) {
        this.servletContext = servletConfig.getServletContext();
    } 
}
org.springframework.web.context.support.StaticWebApplicationContext
@Override public void setServletContext(@Nullable ServletContext servletContext)
{
    this.servletContext = servletContext;
}
 WebApplicationContextUtils
org.springframework.web.context.support.WebApplicationContextUtils
public static WebApplicationContext getRequiredWebApplicationContext(ServletContext sc)
{
    WebApplicationContext wac = getWebApplicationContext(sc);
    if (wac == null) {
        throw new IllegalStateException("No WebApplicationContext found: no ContextLoaderListener registered?");
    } 
    return wac;
}
org.springframework.web.context.support.WebApplicationContextUtils
@Nullable public static WebApplicationContext getWebApplicationContext(ServletContext sc)
{
    return getWebApplicationContext(sc, WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
}
org.springframework.web.context.support.WebApplicationContextUtils
@Nullable public static WebApplicationContext getWebApplicationContext(ServletContext sc, String attrName)
{
    Assert.notNull(sc, "ServletContext must not be null");
    Object attr = sc.getAttribute(attrName);
    if (attr == null) {
        return null;
    } 
    if (attr instanceof RuntimeException) {
        throw (RuntimeException)attr;
    } 
    if (attr instanceof Error) {
        throw (Error)attr;
    } 
    if (attr instanceof Exception) {
        throw new IllegalStateException((Exception)attr);
    } 
    if (!(attr instanceof WebApplicationContext)) {
        throw new IllegalStateException("Context attribute is not of type WebApplicationContext: " + attr);
    } 
    return (WebApplicationContext)attr;
}
org.springframework.web.context.support.WebApplicationContextUtils
public static void initServletPropertySources(MutablePropertySources propertySources, ServletContext servletContext)
{
    initServletPropertySources(propertySources, servletContext, null);
}
org.springframework.web.context.support.WebApplicationContextUtils
public static void initServletPropertySources(MutablePropertySources sources, @Nullable ServletContext servletContext, @Nullable ServletConfig servletConfig)
{
    Assert.notNull(sources, "'propertySources' must not be null");
    String name = StandardServletEnvironment.SERVLET_CONTEXT_PROPERTY_SOURCE_NAME;
    if (servletContext != null && sources.contains(name) && sources.get(name) instanceof StubPropertySource) {
        sources.replace(name, new ServletContextPropertySource(name, servletContext));
    } 
    name = StandardServletEnvironment.SERVLET_CONFIG_PROPERTY_SOURCE_NAME;
    if (servletConfig != null && sources.contains(name) && sources.get(name) instanceof StubPropertySource) {
        sources.replace(name, new ServletConfigPropertySource(name, servletConfig));
    } 
}
org.springframework.web.context.support.WebApplicationContextUtils
public static void registerEnvironmentBeans(ConfigurableListableBeanFactory bf, @Nullable ServletContext sc)
{
    registerEnvironmentBeans(bf, sc, null);
}
org.springframework.web.context.support.WebApplicationContextUtils
public static void registerEnvironmentBeans(ConfigurableListableBeanFactory bf, @Nullable ServletContext servletContext, @Nullable ServletConfig servletConfig)
{
    if (servletContext != null && !bf.containsBean(WebApplicationContext.SERVLET_CONTEXT_BEAN_NAME)) {
        bf.registerSingleton(WebApplicationContext.SERVLET_CONTEXT_BEAN_NAME, servletContext);
    } 
    if (servletConfig != null && !bf.containsBean(ConfigurableWebApplicationContext.SERVLET_CONFIG_BEAN_NAME)) {
        bf.registerSingleton(ConfigurableWebApplicationContext.SERVLET_CONFIG_BEAN_NAME, servletConfig);
    } 
    if (!bf.containsBean(WebApplicationContext.CONTEXT_PARAMETERS_BEAN_NAME)) {
        Map<String, String> parameterMap = new HashMap<>();
        if (servletContext != null) {
            Enumeration<?> paramNameEnum = servletContext.getInitParameterNames();
            while (paramNameEnum.hasMoreElements()) {
                String paramName = (String)paramNameEnum.nextElement();
                parameterMap.put(paramName, servletContext.getInitParameter(paramName));
            }
        } 
        if (servletConfig != null) {
            Enumeration<?> paramNameEnum = servletConfig.getInitParameterNames();
            while (paramNameEnum.hasMoreElements()) {
                String paramName = (String)paramNameEnum.nextElement();
                parameterMap.put(paramName, servletConfig.getInitParameter(paramName));
            }
        } 
        bf.registerSingleton(WebApplicationContext.CONTEXT_PARAMETERS_BEAN_NAME, Collections.unmodifiableMap(parameterMap));
    } 
    if (!bf.containsBean(WebApplicationContext.CONTEXT_ATTRIBUTES_BEAN_NAME)) {
        Map<String, Object> attributeMap = new HashMap<>();
        if (servletContext != null) {
            Enumeration<?> attrNameEnum = servletContext.getAttributeNames();
            while (attrNameEnum.hasMoreElements()) {
                String attrName = (String)attrNameEnum.nextElement();
                attributeMap.put(attrName, servletContext.getAttribute(attrName));
            }
        } 
        bf.registerSingleton(WebApplicationContext.CONTEXT_ATTRIBUTES_BEAN_NAME, Collections.unmodifiableMap(attributeMap));
    } 
}
org.springframework.web.context.support.WebApplicationContextUtils
public static void registerWebApplicationScopes(ConfigurableListableBeanFactory beanFactory)
{
    registerWebApplicationScopes(beanFactory, null);
}
org.springframework.web.context.support.WebApplicationContextUtils
public static void registerWebApplicationScopes(ConfigurableListableBeanFactory beanFactory, @Nullable ServletContext sc)
{
    beanFactory.registerScope(WebApplicationContext.SCOPE_REQUEST, new RequestScope());
    beanFactory.registerScope(WebApplicationContext.SCOPE_SESSION, new SessionScope());
    if (sc != null) {
        ServletContextScope appScope = new ServletContextScope(sc);
        beanFactory.registerScope(WebApplicationContext.SCOPE_APPLICATION, appScope);
        sc.setAttribute(ServletContextScope.class.getName(), appScope);
    } 
    beanFactory.registerResolvableDependency(ServletRequest.class, new RequestObjectFactory());
    beanFactory.registerResolvableDependency(ServletResponse.class, new ResponseObjectFactory());
    beanFactory.registerResolvableDependency(HttpSession.class, new SessionObjectFactory());
    beanFactory.registerResolvableDependency(WebRequest.class, new WebRequestObjectFactory());
    if (jsfPresent) {
        FacesDependencyRegistrar.registerFacesDependencies(beanFactory);
    } 
}
 WebApplicationObjectSupport
 extends ApplicationObjectSupport implements ServletContextAware
org.springframework.web.context.support.WebApplicationObjectSupport
@Nullable protected final ServletContext getServletContext()
{
    if (this.servletContext != null) {
        return this.servletContext;
    } 
    ServletContext servletContext = null;
    WebApplicationContext wac = getWebApplicationContext();
    if (wac != null) {
        servletContext = wac.getServletContext();
    } 
    if (servletContext == null && isContextRequired()) {
        throw new IllegalStateException("WebApplicationObjectSupport instance [" + this + "] does not run within a ServletContext. Make sure the object is fully configured!");
    } 
    return servletContext;
}
org.springframework.web.context.support.WebApplicationObjectSupport
protected void initServletContext(ServletContext servletContext)
{
}
org.springframework.web.context.support.WebApplicationObjectSupport
@Override protected boolean isContextRequired()
{
    return true;
}
org.springframework.web.context.support.WebApplicationObjectSupport
@Override public final void setServletContext(ServletContext servletContext)
{
    if (servletContext != this.servletContext) {
        this.servletContext = servletContext;
        initServletContext(servletContext);
    } 
}
 XmlWebApplicationContext
 extends AbstractRefreshableWebApplicationContext
org.springframework.web.context.support.XmlWebApplicationContext
public static final String DEFAULT_CONFIG_LOCATION
org.springframework.web.context.support.XmlWebApplicationContext
public static final String DEFAULT_CONFIG_LOCATION_PREFIX
org.springframework.web.context.support.XmlWebApplicationContext
public static final String DEFAULT_CONFIG_LOCATION_SUFFIX
org.springframework.web.context.support.XmlWebApplicationContext
@Override protected String[] getDefaultConfigLocations()
{
    if (getNamespace() != null) {
        return new String[]{DEFAULT_CONFIG_LOCATION_PREFIX + getNamespace() + DEFAULT_CONFIG_LOCATION_SUFFIX};
    } else {
        return new String[]{DEFAULT_CONFIG_LOCATION};
    }
}
org.springframework.web.context.support.XmlWebApplicationContext
protected void initBeanDefinitionReader(XmlBeanDefinitionReader beanDefinitionReader)
{
}
org.springframework.web.context.support.XmlWebApplicationContext
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader)
{
    String[] configLocations = getConfigLocations();
    if (configLocations != null) {
        for (String configLocation: configLocations) {
            reader.loadBeanDefinitions(configLocation);
        }
    } 
}
 CorsConfiguration
org.springframework.web.cors.CorsConfiguration
public static final String ALL
org.springframework.web.cors.CorsConfiguration
public CorsConfiguration CorsConfiguration()
{
}
org.springframework.web.cors.CorsConfiguration
public void addAllowedHeader(String allowedHeader)
{
    if (this.allowedHeaders == null) {
        this.allowedHeaders = new ArrayList<>(4);
    } else if (this.allowedHeaders == DEFAULT_PERMIT_ALL) {
        setAllowedHeaders(DEFAULT_PERMIT_ALL);
    } 
    this.allowedHeaders.add(allowedHeader);
}
org.springframework.web.cors.CorsConfiguration
public void addAllowedMethod(HttpMethod method)
{
    addAllowedMethod(method.name());
}
org.springframework.web.cors.CorsConfiguration
public void addAllowedMethod(String method)
{
    if (StringUtils.hasText(method)) {
        if (this.allowedMethods == null) {
            this.allowedMethods = new ArrayList<>(4);
            this.resolvedMethods = new ArrayList<>(4);
        } else if (this.allowedMethods == DEFAULT_PERMIT_METHODS) {
            setAllowedMethods(DEFAULT_PERMIT_METHODS);
        } 
        this.allowedMethods.add(method);
        if (ALL.equals(method)) {
            this.resolvedMethods = null;
        } else if (this.resolvedMethods != null) {
            this.resolvedMethods.add(HttpMethod.resolve(method));
        } 
    } 
}
org.springframework.web.cors.CorsConfiguration
public void addAllowedOrigin(String origin)
{
    if (this.allowedOrigins == null) {
        this.allowedOrigins = new ArrayList<>(4);
    } else if (this.allowedOrigins == DEFAULT_PERMIT_ALL) {
        setAllowedOrigins(DEFAULT_PERMIT_ALL);
    } 
    this.allowedOrigins.add(origin);
}
org.springframework.web.cors.CorsConfiguration
public void addExposedHeader(String exposedHeader)
{
    if (ALL.equals(exposedHeader)) {
        throw new IllegalArgumentException("'*' is not a valid exposed header value");
    } 
    if (this.exposedHeaders == null) {
        this.exposedHeaders = new ArrayList<>(4);
    } 
    this.exposedHeaders.add(exposedHeader);
}
org.springframework.web.cors.CorsConfiguration
public CorsConfiguration applyPermitDefaultValues()
{
    if (this.allowedOrigins == null) {
        this.allowedOrigins = DEFAULT_PERMIT_ALL;
    } 
    if (this.allowedMethods == null) {
        this.allowedMethods = DEFAULT_PERMIT_METHODS;
        this.resolvedMethods = DEFAULT_PERMIT_METHODS.stream().map(HttpMethod::resolve).collect(Collectors.toList());
    } 
    if (this.allowedHeaders == null) {
        this.allowedHeaders = DEFAULT_PERMIT_ALL;
    } 
    if (this.maxAge == null) {
        this.maxAge = 1800L;
    } 
    return this;
}
org.springframework.web.cors.CorsConfiguration
@Nullable public List<String> checkHeaders(@Nullable List<String> requestHeaders)
{
    if (requestHeaders == null) {
        return null;
    } 
    if (requestHeaders.isEmpty()) {
        return Collections.emptyList();
    } 
    if (ObjectUtils.isEmpty(this.allowedHeaders)) {
        return null;
    } 
    boolean allowAnyHeader = this.allowedHeaders.contains(ALL);
    List<String> result = new ArrayList<>(requestHeaders.size());
    for (String requestHeader: requestHeaders) {
        if (StringUtils.hasText(requestHeader)) {
            requestHeader = requestHeader.trim();
            if (allowAnyHeader) {
                result.add(requestHeader);
            } else {
                for (String allowedHeader: this.allowedHeaders) {
                    if (requestHeader.equalsIgnoreCase(allowedHeader)) {
                        result.add(requestHeader);
                        break;
                    } 
                }
            }
        } 
    }
    return (result.isEmpty() ? null : result);
}
org.springframework.web.cors.CorsConfiguration
@Nullable public List<HttpMethod> checkHttpMethod(@Nullable HttpMethod requestMethod)
{
    if (requestMethod == null) {
        return null;
    } 
    if (this.resolvedMethods == null) {
        return Collections.singletonList(requestMethod);
    } 
    return (this.resolvedMethods.contains(requestMethod) ? this.resolvedMethods : null);
}
org.springframework.web.cors.CorsConfiguration
@Nullable public String checkOrigin(@Nullable String requestOrigin)
{
    if (!StringUtils.hasText(requestOrigin)) {
        return null;
    } 
    if (ObjectUtils.isEmpty(this.allowedOrigins)) {
        return null;
    } 
    if (this.allowedOrigins.contains(ALL)) {
        if (this.allowCredentials != Boolean.TRUE) {
            return ALL;
        } else {
            return requestOrigin;
        }
    } 
    for (String allowedOrigin: this.allowedOrigins) {
        if (requestOrigin.equalsIgnoreCase(allowedOrigin)) {
            return requestOrigin;
        } 
    }
    return null;
}
org.springframework.web.cors.CorsConfiguration
@Nullable public CorsConfiguration combine(@Nullable CorsConfiguration other)
{
    if (other == null) {
        return this;
    } 
    CorsConfiguration config = new CorsConfiguration(this);
    config.setAllowedOrigins(combine(getAllowedOrigins(), other.getAllowedOrigins()));
    config.setAllowedMethods(combine(getAllowedMethods(), other.getAllowedMethods()));
    config.setAllowedHeaders(combine(getAllowedHeaders(), other.getAllowedHeaders()));
    config.setExposedHeaders(combine(getExposedHeaders(), other.getExposedHeaders()));
    Boolean allowCredentials = other.getAllowCredentials();
    if (allowCredentials != null) {
        config.setAllowCredentials(allowCredentials);
    } 
    Long maxAge = other.getMaxAge();
    if (maxAge != null) {
        config.setMaxAge(maxAge);
    } 
    return config;
}
org.springframework.web.cors.CorsConfiguration
@Nullable public Boolean getAllowCredentials()
{
    return this.allowCredentials;
}
org.springframework.web.cors.CorsConfiguration
@Nullable public List<String> getAllowedHeaders()
{
    return this.allowedHeaders;
}
org.springframework.web.cors.CorsConfiguration
@Nullable public List<String> getAllowedMethods()
{
    return this.allowedMethods;
}
org.springframework.web.cors.CorsConfiguration
@Nullable public List<String> getAllowedOrigins()
{
    return this.allowedOrigins;
}
org.springframework.web.cors.CorsConfiguration
@Nullable public List<String> getExposedHeaders()
{
    return this.exposedHeaders;
}
org.springframework.web.cors.CorsConfiguration
@Nullable public Long getMaxAge()
{
    return this.maxAge;
}
org.springframework.web.cors.CorsConfiguration
public void setAllowCredentials(@Nullable Boolean allowCredentials)
{
    this.allowCredentials = allowCredentials;
}
org.springframework.web.cors.CorsConfiguration
public void setAllowedHeaders(@Nullable List<String> allowedHeaders)
{
    this.allowedHeaders = (allowedHeaders != null ? new ArrayList<>(allowedHeaders) : null);
}
org.springframework.web.cors.CorsConfiguration
public void setAllowedOrigins(@Nullable List<String> allowedOrigins)
{
    this.allowedOrigins = (allowedOrigins != null ? new ArrayList<>(allowedOrigins) : null);
}
org.springframework.web.cors.CorsConfiguration
public void setExposedHeaders(@Nullable List<String> exposedHeaders)
{
    if (exposedHeaders != null && exposedHeaders.contains(ALL)) {
        throw new IllegalArgumentException("'*' is not a valid exposed header value");
    } 
    this.exposedHeaders = (exposedHeaders != null ? new ArrayList<>(exposedHeaders) : null);
}
org.springframework.web.cors.CorsConfiguration
public void setMaxAge(Duration maxAge)
{
    this.maxAge = maxAge.getSeconds();
}
org.springframework.web.cors.CorsConfiguration
public void setMaxAge(@Nullable Long maxAge)
{
    this.maxAge = maxAge;
}
 CorsConfigurationSource
 CorsProcessor
 CorsUtils
org.springframework.web.cors.CorsUtils
public static boolean isCorsRequest(HttpServletRequest request)
{
    String origin = request.getHeader(HttpHeaders.ORIGIN);
    if (origin == null) {
        return false;
    } 
    UriComponents originUrl = UriComponentsBuilder.fromOriginHeader(origin).build();
    String scheme = request.getScheme();
    String host = request.getServerName();
    int port = request.getServerPort();
    return !(ObjectUtils.nullSafeEquals(scheme, originUrl.getScheme()) && ObjectUtils.nullSafeEquals(host, originUrl.getHost()) && getPort(scheme, port) == getPort(originUrl.getScheme(), originUrl.getPort()));
}
org.springframework.web.cors.CorsUtils
public static boolean isPreFlightRequest(HttpServletRequest request)
{
    return (HttpMethod.OPTIONS.matches(request.getMethod()) && request.getHeader(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD) != null);
}
 DefaultCorsProcessor
 implements CorsProcessor
org.springframework.web.cors.DefaultCorsProcessor
@Nullable protected List<String> checkHeaders(CorsConfiguration config, List<String> requestHeaders)
{
    return config.checkHeaders(requestHeaders);
}
org.springframework.web.cors.DefaultCorsProcessor
@Nullable protected List<HttpMethod> checkMethods(CorsConfiguration config, @Nullable HttpMethod requestMethod)
{
    return config.checkHttpMethod(requestMethod);
}
org.springframework.web.cors.DefaultCorsProcessor
@Nullable protected String checkOrigin(CorsConfiguration config, @Nullable String requestOrigin)
{
    return config.checkOrigin(requestOrigin);
}
org.springframework.web.cors.DefaultCorsProcessor
protected boolean handleInternal(ServerHttpRequest request, ServerHttpResponse response, CorsConfiguration config, boolean preFlightRequest)
{
    String requestOrigin = request.getHeaders().getOrigin();
    String allowOrigin = checkOrigin(config, requestOrigin);
    HttpHeaders responseHeaders = response.getHeaders();
    if (allowOrigin == null) {
        logger.debug("Reject: '" + requestOrigin + "' origin is not allowed");
        rejectRequest(response);
        return false;
    } 
    HttpMethod requestMethod = getMethodToUse(request, preFlightRequest);
    List<HttpMethod> allowMethods = checkMethods(config, requestMethod);
    if (allowMethods == null) {
        logger.debug("Reject: HTTP '" + requestMethod + "' is not allowed");
        rejectRequest(response);
        return false;
    } 
    List<String> requestHeaders = getHeadersToUse(request, preFlightRequest);
    List<String> allowHeaders = checkHeaders(config, requestHeaders);
    if (preFlightRequest && allowHeaders == null) {
        logger.debug("Reject: headers '" + requestHeaders + "' are not allowed");
        rejectRequest(response);
        return false;
    } 
    responseHeaders.setAccessControlAllowOrigin(allowOrigin);
    if (preFlightRequest) {
        responseHeaders.setAccessControlAllowMethods(allowMethods);
    } 
    if (preFlightRequest && !allowHeaders.isEmpty()) {
        responseHeaders.setAccessControlAllowHeaders(allowHeaders);
    } 
    if (!CollectionUtils.isEmpty(config.getExposedHeaders())) {
        responseHeaders.setAccessControlExposeHeaders(config.getExposedHeaders());
    } 
    if (Boolean.TRUE.equals(config.getAllowCredentials())) {
        responseHeaders.setAccessControlAllowCredentials(true);
    } 
    if (preFlightRequest && config.getMaxAge() != null) {
        responseHeaders.setAccessControlMaxAge(config.getMaxAge());
    } 
    response.flush();
    return true;
}
org.springframework.web.cors.DefaultCorsProcessor
@Override @SuppressWarnings("resource") public boolean processRequest(@Nullable CorsConfiguration config, HttpServletRequest request, HttpServletResponse response)
{
    response.addHeader(HttpHeaders.VARY, HttpHeaders.ORIGIN);
    response.addHeader(HttpHeaders.VARY, HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD);
    response.addHeader(HttpHeaders.VARY, HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS);
    if (!CorsUtils.isCorsRequest(request)) {
        return true;
    } 
    if (response.getHeader(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN) != null) {
        logger.trace("Skip: response already contains \"Access-Control-Allow-Origin\"");
        return true;
    } 
    boolean preFlightRequest = CorsUtils.isPreFlightRequest(request);
    if (config == null) {
        if (preFlightRequest) {
            rejectRequest(new ServletServerHttpResponse(response));
            return false;
        } else {
            return true;
        }
    } 
    return handleInternal(new ServletServerHttpRequest(request), new ServletServerHttpResponse(response), config, preFlightRequest);
}
org.springframework.web.cors.DefaultCorsProcessor
protected void rejectRequest(ServerHttpResponse response)
{
    response.setStatusCode(HttpStatus.FORBIDDEN);
    response.getBody().write("Invalid CORS request".getBytes(StandardCharsets.UTF_8));
    response.flush();
}
 UrlBasedCorsConfigurationSource
 implements CorsConfigurationSource
org.springframework.web.cors.UrlBasedCorsConfigurationSource
public Map<String, CorsConfiguration> getCorsConfigurations()
{
    return Collections.unmodifiableMap(this.corsConfigurations);
}
org.springframework.web.cors.UrlBasedCorsConfigurationSource
public void registerCorsConfiguration(String path, CorsConfiguration config)
{
    this.corsConfigurations.put(path, config);
}
org.springframework.web.cors.UrlBasedCorsConfigurationSource
public void setAlwaysUseFullPath(boolean alwaysUseFullPath)
{
    this.urlPathHelper.setAlwaysUseFullPath(alwaysUseFullPath);
}
org.springframework.web.cors.UrlBasedCorsConfigurationSource
public void setCorsConfigurations(@Nullable Map<String, CorsConfiguration> corsConfigurations)
{
    this.corsConfigurations.clear();
    if (corsConfigurations != null) {
        this.corsConfigurations.putAll(corsConfigurations);
    } 
}
org.springframework.web.cors.UrlBasedCorsConfigurationSource
public void setLookupPathAttributeName(@Nullable String lookupPathAttributeName)
{
    this.lookupPathAttributeName = lookupPathAttributeName;
}
org.springframework.web.cors.UrlBasedCorsConfigurationSource
public void setPathMatcher(PathMatcher pathMatcher)
{
    Assert.notNull(pathMatcher, "PathMatcher must not be null");
    this.pathMatcher = pathMatcher;
}
org.springframework.web.cors.UrlBasedCorsConfigurationSource
public void setRemoveSemicolonContent(boolean removeSemicolonContent)
{
    this.urlPathHelper.setRemoveSemicolonContent(removeSemicolonContent);
}
org.springframework.web.cors.UrlBasedCorsConfigurationSource
public void setUrlDecode(boolean urlDecode)
{
    this.urlPathHelper.setUrlDecode(urlDecode);
}
org.springframework.web.cors.UrlBasedCorsConfigurationSource
public void setUrlPathHelper(UrlPathHelper urlPathHelper)
{
    Assert.notNull(urlPathHelper, "UrlPathHelper must not be null");
    this.urlPathHelper = urlPathHelper;
}
 CorsConfigurationSource
 CorsProcessor
 CorsUtils
org.springframework.web.cors.reactive.CorsUtils
@SuppressWarnings("deprecation") public static boolean isCorsRequest(ServerHttpRequest request)
{
    return request.getHeaders().containsKey(HttpHeaders.ORIGIN) && !isSameOrigin(request);
}
org.springframework.web.cors.reactive.CorsUtils
public static boolean isPreFlightRequest(ServerHttpRequest request)
{
    return (request.getMethod() == HttpMethod.OPTIONS && request.getHeaders().containsKey(HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD));
}
org.springframework.web.cors.reactive.CorsUtils
@Deprecated public static boolean isSameOrigin(ServerHttpRequest request)
{
    String origin = request.getHeaders().getOrigin();
    if (origin == null) {
        return true;
    } 
    URI uri = request.getURI();
    String actualScheme = uri.getScheme();
    String actualHost = uri.getHost();
    int actualPort = getPort(uri.getScheme(), uri.getPort());
    Assert.notNull(actualScheme, "Actual request scheme must not be null");
    Assert.notNull(actualHost, "Actual request host must not be null");
    Assert.isTrue(actualPort != -1, "Actual request port must not be undefined");
    UriComponents originUrl = UriComponentsBuilder.fromOriginHeader(origin).build();
    return (actualScheme.equals(originUrl.getScheme()) && actualHost.equals(originUrl.getHost()) && actualPort == getPort(originUrl.getScheme(), originUrl.getPort()));
}
 CorsWebFilter
 implements WebFilter
org.springframework.web.cors.reactive.CorsWebFilter
public CorsWebFilter CorsWebFilter(CorsConfigurationSource configSource)
{
    this(configSource, new DefaultCorsProcessor());
}
org.springframework.web.cors.reactive.CorsWebFilter
public CorsWebFilter CorsWebFilter(CorsConfigurationSource configSource, CorsProcessor processor)
{
    Assert.notNull(configSource, "CorsConfigurationSource must not be null");
    Assert.notNull(processor, "CorsProcessor must not be null");
    this.configSource = configSource;
    this.processor = processor;
}
 DefaultCorsProcessor
 implements CorsProcessor
org.springframework.web.cors.reactive.DefaultCorsProcessor
@Nullable protected List<String> checkHeaders(CorsConfiguration config, List<String> requestHeaders)
{
    return config.checkHeaders(requestHeaders);
}
org.springframework.web.cors.reactive.DefaultCorsProcessor
@Nullable protected List<HttpMethod> checkMethods(CorsConfiguration config, @Nullable HttpMethod requestMethod)
{
    return config.checkHttpMethod(requestMethod);
}
org.springframework.web.cors.reactive.DefaultCorsProcessor
@Nullable protected String checkOrigin(CorsConfiguration config, @Nullable String requestOrigin)
{
    return config.checkOrigin(requestOrigin);
}
org.springframework.web.cors.reactive.DefaultCorsProcessor
protected boolean handleInternal(ServerWebExchange exchange, CorsConfiguration config, boolean preFlightRequest)
{
    ServerHttpRequest request = exchange.getRequest();
    ServerHttpResponse response = exchange.getResponse();
    HttpHeaders responseHeaders = response.getHeaders();
    String requestOrigin = request.getHeaders().getOrigin();
    String allowOrigin = checkOrigin(config, requestOrigin);
    if (allowOrigin == null) {
        logger.debug("Reject: '" + requestOrigin + "' origin is not allowed");
        rejectRequest(response);
        return false;
    } 
    HttpMethod requestMethod = getMethodToUse(request, preFlightRequest);
    List<HttpMethod> allowMethods = checkMethods(config, requestMethod);
    if (allowMethods == null) {
        logger.debug("Reject: HTTP '" + requestMethod + "' is not allowed");
        rejectRequest(response);
        return false;
    } 
    List<String> requestHeaders = getHeadersToUse(request, preFlightRequest);
    List<String> allowHeaders = checkHeaders(config, requestHeaders);
    if (preFlightRequest && allowHeaders == null) {
        logger.debug("Reject: headers '" + requestHeaders + "' are not allowed");
        rejectRequest(response);
        return false;
    } 
    responseHeaders.setAccessControlAllowOrigin(allowOrigin);
    if (preFlightRequest) {
        responseHeaders.setAccessControlAllowMethods(allowMethods);
    } 
    if (preFlightRequest && !allowHeaders.isEmpty()) {
        responseHeaders.setAccessControlAllowHeaders(allowHeaders);
    } 
    if (!CollectionUtils.isEmpty(config.getExposedHeaders())) {
        responseHeaders.setAccessControlExposeHeaders(config.getExposedHeaders());
    } 
    if (Boolean.TRUE.equals(config.getAllowCredentials())) {
        responseHeaders.setAccessControlAllowCredentials(true);
    } 
    if (preFlightRequest && config.getMaxAge() != null) {
        responseHeaders.setAccessControlMaxAge(config.getMaxAge());
    } 
    return true;
}
org.springframework.web.cors.reactive.DefaultCorsProcessor
@Override public boolean process(@Nullable CorsConfiguration config, ServerWebExchange exchange)
{
    ServerHttpRequest request = exchange.getRequest();
    ServerHttpResponse response = exchange.getResponse();
    response.getHeaders().addAll(HttpHeaders.VARY, VARY_HEADERS);
    if (!CorsUtils.isCorsRequest(request)) {
        return true;
    } 
    if (response.getHeaders().getFirst(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN) != null) {
        logger.trace("Skip: response already contains \"Access-Control-Allow-Origin\"");
        return true;
    } 
    boolean preFlightRequest = CorsUtils.isPreFlightRequest(request);
    if (config == null) {
        if (preFlightRequest) {
            rejectRequest(response);
            return false;
        } else {
            return true;
        }
    } 
    return handleInternal(exchange, config, preFlightRequest);
}
org.springframework.web.cors.reactive.DefaultCorsProcessor
protected void rejectRequest(ServerHttpResponse response)
{
    response.setStatusCode(HttpStatus.FORBIDDEN);
}
 UrlBasedCorsConfigurationSource
 implements CorsConfigurationSource
org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource
public UrlBasedCorsConfigurationSource UrlBasedCorsConfigurationSource()
{
    this(new PathPatternParser());
}
org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource
public UrlBasedCorsConfigurationSource UrlBasedCorsConfigurationSource(PathPatternParser patternParser)
{
    this.corsConfigurations = new LinkedHashMap<>();
    this.patternParser = patternParser;
}
org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource
@Override @Nullable public CorsConfiguration getCorsConfiguration(ServerWebExchange exchange)
{
    PathContainer lookupPath = exchange.getRequest().getPath().pathWithinApplication();
    return this.corsConfigurations.entrySet().stream().filter(entry -> entry.getKey().matches(lookupPath)).map(Map.Entry::getValue).findFirst().orElse(null);
}
org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource
public void registerCorsConfiguration(String path, CorsConfiguration config)
{
    this.corsConfigurations.put(this.patternParser.parse(path), config);
}
org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource
public void setCorsConfigurations(@Nullable Map<String, CorsConfiguration> corsConfigurations)
{
    this.corsConfigurations.clear();
    if (corsConfigurations != null) {
        corsConfigurations.forEach(this::registerCorsConfiguration);
    } 
}
 AbstractRequestLoggingFilter
 extends OncePerRequestFilter
org.springframework.web.filter.AbstractRequestLoggingFilter
public static final String DEFAULT_AFTER_MESSAGE_PREFIX
org.springframework.web.filter.AbstractRequestLoggingFilter
public static final String DEFAULT_AFTER_MESSAGE_SUFFIX
org.springframework.web.filter.AbstractRequestLoggingFilter
public static final String DEFAULT_BEFORE_MESSAGE_PREFIX
org.springframework.web.filter.AbstractRequestLoggingFilter
public static final String DEFAULT_BEFORE_MESSAGE_SUFFIX
org.springframework.web.filter.AbstractRequestLoggingFilter
protected abstract void afterRequest(HttpServletRequest request, String message)
org.springframework.web.filter.AbstractRequestLoggingFilter
protected abstract void beforeRequest(HttpServletRequest request, String message)
org.springframework.web.filter.AbstractRequestLoggingFilter
@Nullable public Predicate<String> getHeaderPredicate()
{
    return this.headerPredicate;
}
org.springframework.web.filter.AbstractRequestLoggingFilter
protected int getMaxPayloadLength()
{
    return this.maxPayloadLength;
}
org.springframework.web.filter.AbstractRequestLoggingFilter
protected boolean isIncludeClientInfo()
{
    return this.includeClientInfo;
}
org.springframework.web.filter.AbstractRequestLoggingFilter
protected boolean isIncludeHeaders()
{
    return this.includeHeaders;
}
org.springframework.web.filter.AbstractRequestLoggingFilter
protected boolean isIncludePayload()
{
    return this.includePayload;
}
org.springframework.web.filter.AbstractRequestLoggingFilter
protected boolean isIncludeQueryString()
{
    return this.includeQueryString;
}
org.springframework.web.filter.AbstractRequestLoggingFilter
public void setAfterMessagePrefix(String afterMessagePrefix)
{
    this.afterMessagePrefix = afterMessagePrefix;
}
org.springframework.web.filter.AbstractRequestLoggingFilter
public void setAfterMessageSuffix(String afterMessageSuffix)
{
    this.afterMessageSuffix = afterMessageSuffix;
}
org.springframework.web.filter.AbstractRequestLoggingFilter
public void setBeforeMessagePrefix(String beforeMessagePrefix)
{
    this.beforeMessagePrefix = beforeMessagePrefix;
}
org.springframework.web.filter.AbstractRequestLoggingFilter
public void setBeforeMessageSuffix(String beforeMessageSuffix)
{
    this.beforeMessageSuffix = beforeMessageSuffix;
}
org.springframework.web.filter.AbstractRequestLoggingFilter
public void setHeaderPredicate(@Nullable Predicate<String> headerPredicate)
{
    this.headerPredicate = headerPredicate;
}
org.springframework.web.filter.AbstractRequestLoggingFilter
public void setIncludeClientInfo(boolean includeClientInfo)
{
    this.includeClientInfo = includeClientInfo;
}
org.springframework.web.filter.AbstractRequestLoggingFilter
public void setIncludeHeaders(boolean includeHeaders)
{
    this.includeHeaders = includeHeaders;
}
org.springframework.web.filter.AbstractRequestLoggingFilter
public void setIncludePayload(boolean includePayload)
{
    this.includePayload = includePayload;
}
org.springframework.web.filter.AbstractRequestLoggingFilter
public void setIncludeQueryString(boolean includeQueryString)
{
    this.includeQueryString = includeQueryString;
}
org.springframework.web.filter.AbstractRequestLoggingFilter
public void setMaxPayloadLength(int maxPayloadLength)
{
    Assert.isTrue(maxPayloadLength >= 0, "'maxPayloadLength' should be larger than or equal to 0");
    this.maxPayloadLength = maxPayloadLength;
}
org.springframework.web.filter.AbstractRequestLoggingFilter
protected boolean shouldLog(HttpServletRequest request)
{
    return true;
}
org.springframework.web.filter.AbstractRequestLoggingFilter
@Override protected boolean shouldNotFilterAsyncDispatch()
{
    return false;
}
 CharacterEncodingFilter
 extends OncePerRequestFilter
org.springframework.web.filter.CharacterEncodingFilter
public CharacterEncodingFilter CharacterEncodingFilter()
{
}
org.springframework.web.filter.CharacterEncodingFilter
public CharacterEncodingFilter CharacterEncodingFilter(String encoding)
{
    this(encoding, false);
}
org.springframework.web.filter.CharacterEncodingFilter
public CharacterEncodingFilter CharacterEncodingFilter(String encoding, boolean forceEncoding)
{
    this(encoding, forceEncoding, forceEncoding);
}
org.springframework.web.filter.CharacterEncodingFilter
public CharacterEncodingFilter CharacterEncodingFilter(String encoding, boolean forceRequestEncoding, boolean forceResponseEncoding)
{
    Assert.hasLength(encoding, "Encoding must not be empty");
    this.encoding = encoding;
    this.forceRequestEncoding = forceRequestEncoding;
    this.forceResponseEncoding = forceResponseEncoding;
}
org.springframework.web.filter.CharacterEncodingFilter
@Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
{
    String encoding = getEncoding();
    if (encoding != null) {
        if (isForceRequestEncoding() || request.getCharacterEncoding() == null) {
            request.setCharacterEncoding(encoding);
        } 
        if (isForceResponseEncoding()) {
            response.setCharacterEncoding(encoding);
        } 
    } 
    filterChain.doFilter(request, response);
}
org.springframework.web.filter.CharacterEncodingFilter
@Nullable public String getEncoding()
{
    return this.encoding;
}
org.springframework.web.filter.CharacterEncodingFilter
public boolean isForceRequestEncoding()
{
    return this.forceRequestEncoding;
}
org.springframework.web.filter.CharacterEncodingFilter
public boolean isForceResponseEncoding()
{
    return this.forceResponseEncoding;
}
org.springframework.web.filter.CharacterEncodingFilter
public void setEncoding(@Nullable String encoding)
{
    this.encoding = encoding;
}
org.springframework.web.filter.CharacterEncodingFilter
public void setForceEncoding(boolean forceEncoding)
{
    this.forceRequestEncoding = forceEncoding;
    this.forceResponseEncoding = forceEncoding;
}
org.springframework.web.filter.CharacterEncodingFilter
public void setForceRequestEncoding(boolean forceRequestEncoding)
{
    this.forceRequestEncoding = forceRequestEncoding;
}
org.springframework.web.filter.CharacterEncodingFilter
public void setForceResponseEncoding(boolean forceResponseEncoding)
{
    this.forceResponseEncoding = forceResponseEncoding;
}
 CommonsRequestLoggingFilter
 extends AbstractRequestLoggingFilter
org.springframework.web.filter.CommonsRequestLoggingFilter
@Override protected void afterRequest(HttpServletRequest request, String message)
{
    logger.debug(message);
}
org.springframework.web.filter.CommonsRequestLoggingFilter
@Override protected void beforeRequest(HttpServletRequest request, String message)
{
    logger.debug(message);
}
org.springframework.web.filter.CommonsRequestLoggingFilter
@Override protected boolean shouldLog(HttpServletRequest request)
{
    return logger.isDebugEnabled();
}
 CompositeFilter
 implements Filter
org.springframework.web.filter.CompositeFilter
@Override public void destroy()
{
    for (int i = this.filters.size(); i-- > 0; ) {
        Filter filter = this.filters.get(i);
        filter.destroy();
    }
}
org.springframework.web.filter.CompositeFilter
@Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
{
    new VirtualFilterChain(chain, this.filters).doFilter(request, response);
}
org.springframework.web.filter.CompositeFilter
@Override public void init(FilterConfig config)
{
    for (Filter filter: this.filters) {
        filter.init(config);
    }
}
org.springframework.web.filter.CompositeFilter
public void setFilters(List<?> filters)
{
    this.filters = new ArrayList<>(filters);
}
 CorsFilter
 extends OncePerRequestFilter
org.springframework.web.filter.CorsFilter
public CorsFilter CorsFilter(CorsConfigurationSource configSource)
{
    Assert.notNull(configSource, "CorsConfigurationSource must not be null");
    this.configSource = configSource;
}
org.springframework.web.filter.CorsFilter
@Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
{
    CorsConfiguration corsConfiguration = this.configSource.getCorsConfiguration(request);
    boolean isValid = this.processor.processRequest(corsConfiguration, request, response);
    if (!isValid || CorsUtils.isPreFlightRequest(request)) {
        return ;
    } 
    filterChain.doFilter(request, response);
}
org.springframework.web.filter.CorsFilter
public void setCorsProcessor(CorsProcessor processor)
{
    Assert.notNull(processor, "CorsProcessor must not be null");
    this.processor = processor;
}
 DelegatingFilterProxy
 extends GenericFilterBean
org.springframework.web.filter.DelegatingFilterProxy
public DelegatingFilterProxy DelegatingFilterProxy()
{
}
org.springframework.web.filter.DelegatingFilterProxy
public DelegatingFilterProxy DelegatingFilterProxy(Filter delegate)
{
    Assert.notNull(delegate, "Delegate Filter must not be null");
    this.delegate = delegate;
}
org.springframework.web.filter.DelegatingFilterProxy
public DelegatingFilterProxy DelegatingFilterProxy(String targetBeanName)
{
    this(targetBeanName, null);
}
org.springframework.web.filter.DelegatingFilterProxy
public DelegatingFilterProxy DelegatingFilterProxy(String targetBeanName, @Nullable WebApplicationContext wac)
{
    Assert.hasText(targetBeanName, "Target Filter bean name must not be null or empty");
    this.setTargetBeanName(targetBeanName);
    this.webApplicationContext = wac;
    if (wac != null) {
        this.setEnvironment(wac.getEnvironment());
    } 
}
org.springframework.web.filter.DelegatingFilterProxy
@Nullable volatile Filter delegate
org.springframework.web.filter.DelegatingFilterProxy
@Override public void destroy()
{
    Filter delegateToUse = this.delegate;
    if (delegateToUse != null) {
        destroyDelegate(delegateToUse);
    } 
}
org.springframework.web.filter.DelegatingFilterProxy
protected void destroyDelegate(Filter delegate)
{
    if (isTargetFilterLifecycle()) {
        delegate.destroy();
    } 
}
org.springframework.web.filter.DelegatingFilterProxy
@Override public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
{
    Filter delegateToUse = this.delegate;
    if (delegateToUse == null) {
        synchronized(this.delegateMonitor) {
            delegateToUse = this.delegate;
            if (delegateToUse == null) {
                WebApplicationContext wac = findWebApplicationContext();
                if (wac == null) {
                    throw new IllegalStateException("No WebApplicationContext found: " + "no ContextLoaderListener or DispatcherServlet registered?");
                } 
                delegateToUse = initDelegate(wac);
            } 
            this.delegate = delegateToUse;
        }
    } 
    invokeDelegate(delegateToUse, request, response, filterChain);
}
org.springframework.web.filter.DelegatingFilterProxy
@Nullable public String getContextAttribute()
{
    return this.contextAttribute;
}
org.springframework.web.filter.DelegatingFilterProxy
@Nullable protected String getTargetBeanName()
{
    return this.targetBeanName;
}
org.springframework.web.filter.DelegatingFilterProxy
@Override protected void initFilterBean()
{
    synchronized(this.delegateMonitor) {
        if (this.delegate == null) {
            if (this.targetBeanName == null) {
                this.targetBeanName = getFilterName();
            } 
            WebApplicationContext wac = findWebApplicationContext();
            if (wac != null) {
                this.delegate = initDelegate(wac);
            } 
        } 
    }
}
org.springframework.web.filter.DelegatingFilterProxy
protected void invokeDelegate(Filter delegate, ServletRequest request, ServletResponse response, FilterChain filterChain)
{
    delegate.doFilter(request, response, filterChain);
}
org.springframework.web.filter.DelegatingFilterProxy
protected boolean isTargetFilterLifecycle()
{
    return this.targetFilterLifecycle;
}
org.springframework.web.filter.DelegatingFilterProxy
public void setContextAttribute(@Nullable String contextAttribute)
{
    this.contextAttribute = contextAttribute;
}
org.springframework.web.filter.DelegatingFilterProxy
public void setTargetBeanName(@Nullable String targetBeanName)
{
    this.targetBeanName = targetBeanName;
}
org.springframework.web.filter.DelegatingFilterProxy
public void setTargetFilterLifecycle(boolean targetFilterLifecycle)
{
    this.targetFilterLifecycle = targetFilterLifecycle;
}
 FormContentFilter
 extends OncePerRequestFilter
org.springframework.web.filter.FormContentFilter
@Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
{
    MultiValueMap<String, String> params = parseIfNecessary(request);
    if (!CollectionUtils.isEmpty(params)) {
        filterChain.doFilter(new FormContentRequestWrapper(request, params), response);
    } else {
        filterChain.doFilter(request, response);
    }
}
org.springframework.web.filter.FormContentFilter
public void setCharset(Charset charset)
{
    this.formConverter.setCharset(charset);
}
org.springframework.web.filter.FormContentFilter
public void setFormConverter(FormHttpMessageConverter converter)
{
    Assert.notNull(converter, "FormHttpMessageConverter is required");
    this.formConverter = converter;
}
 ForwardedHeaderFilter
 extends OncePerRequestFilter
org.springframework.web.filter.ForwardedHeaderFilter
public ForwardedHeaderFilter ForwardedHeaderFilter()
{
    this.pathHelper = new UrlPathHelper();
    this.pathHelper.setUrlDecode(false);
    this.pathHelper.setRemoveSemicolonContent(false);
}
org.springframework.web.filter.ForwardedHeaderFilter
@Override protected void doFilterNestedErrorDispatch(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
{
    doFilterInternal(request, response, filterChain);
}
org.springframework.web.filter.ForwardedHeaderFilter
public void setRelativeRedirects(boolean relativeRedirects)
{
    this.relativeRedirects = relativeRedirects;
}
org.springframework.web.filter.ForwardedHeaderFilter
public void setRemoveOnly(boolean removeOnly)
{
    this.removeOnly = removeOnly;
}
org.springframework.web.filter.ForwardedHeaderFilter
@Override protected boolean shouldNotFilter(HttpServletRequest request)
{
    for (String headerName: FORWARDED_HEADER_NAMES) {
        if (request.getHeader(headerName) != null) {
            return false;
        } 
    }
    return true;
}
org.springframework.web.filter.ForwardedHeaderFilter
@Override protected boolean shouldNotFilterAsyncDispatch()
{
    return false;
}
org.springframework.web.filter.ForwardedHeaderFilter
@Override protected boolean shouldNotFilterErrorDispatch()
{
    return false;
}
 GenericFilterBean
 implements Filter, BeanNameAware, EnvironmentAware, EnvironmentCapable, ServletContextAware, InitializingBean, DisposableBean
org.springframework.web.filter.GenericFilterBean
protected final void addRequiredProperty(String property)
{
    this.requiredProperties.add(property);
}
org.springframework.web.filter.GenericFilterBean
@Override public void afterPropertiesSet()
{
    initFilterBean();
}
org.springframework.web.filter.GenericFilterBean
protected Environment createEnvironment()
{
    return new StandardServletEnvironment();
}
org.springframework.web.filter.GenericFilterBean
@Override public void destroy()
{
}
org.springframework.web.filter.GenericFilterBean
@Override public Environment getEnvironment()
{
    if (this.environment == null) {
        this.environment = createEnvironment();
    } 
    return this.environment;
}
org.springframework.web.filter.GenericFilterBean
@Nullable public FilterConfig getFilterConfig()
{
    return this.filterConfig;
}
org.springframework.web.filter.GenericFilterBean
@Nullable protected String getFilterName()
{
    return (this.filterConfig != null ? this.filterConfig.getFilterName() : this.beanName);
}
org.springframework.web.filter.GenericFilterBean
protected ServletContext getServletContext()
{
    if (this.filterConfig != null) {
        return this.filterConfig.getServletContext();
    } else if (this.servletContext != null) {
        return this.servletContext;
    } else {
        throw new IllegalStateException("No ServletContext");
    }
}
org.springframework.web.filter.GenericFilterBean
protected void initBeanWrapper(BeanWrapper bw)
{
}
org.springframework.web.filter.GenericFilterBean
protected void initFilterBean()
{
}
org.springframework.web.filter.GenericFilterBean
protected final Log logger
org.springframework.web.filter.GenericFilterBean
@Override public void setBeanName(String beanName)
{
    this.beanName = beanName;
}
org.springframework.web.filter.GenericFilterBean
@Override public void setEnvironment(Environment environment)
{
    this.environment = environment;
}
org.springframework.web.filter.GenericFilterBean
@Override public void setServletContext(ServletContext servletContext)
{
    this.servletContext = servletContext;
}
 HiddenHttpMethodFilter
 extends OncePerRequestFilter
org.springframework.web.filter.HiddenHttpMethodFilter
public static final String DEFAULT_METHOD_PARAM
org.springframework.web.filter.HiddenHttpMethodFilter
public void setMethodParam(String methodParam)
{
    Assert.hasText(methodParam, "'methodParam' must not be empty");
    this.methodParam = methodParam;
}
 HttpPutFormContentFilter
 extends OncePerRequestFilter
org.springframework.web.filter.HttpPutFormContentFilter
@Override protected void doFilterInternal(final HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
{
    if (("PUT".equals(request.getMethod()) || "PATCH".equals(request.getMethod())) && isFormContentType(request)) {
        HttpInputMessage inputMessage = new ServletServerHttpRequest(request) {
            @Override
            public InputStream getBody() throws IOException{
                return request.getInputStream();
            }
        };
        MultiValueMap<String, String> formParameters = this.formConverter.read(null, inputMessage);
        if (!formParameters.isEmpty()) {
            HttpServletRequest wrapper = new HttpPutFormContentRequestWrapper(request, formParameters);
            filterChain.doFilter(wrapper, response);
            return ;
        } 
    } 
    filterChain.doFilter(request, response);
}
org.springframework.web.filter.HttpPutFormContentFilter
public FormHttpMessageConverter getFormConverter()
{
    return this.formConverter;
}
org.springframework.web.filter.HttpPutFormContentFilter
public void setCharset(Charset charset)
{
    this.formConverter.setCharset(charset);
}
org.springframework.web.filter.HttpPutFormContentFilter
public void setFormConverter(FormHttpMessageConverter converter)
{
    Assert.notNull(converter, "FormHttpMessageConverter is required.");
    this.formConverter = converter;
}
 OncePerRequestFilter
 extends GenericFilterBean
org.springframework.web.filter.OncePerRequestFilter
public static final String ALREADY_FILTERED_SUFFIX
org.springframework.web.filter.OncePerRequestFilter
@Override public final void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
{
    if (!(request instanceof HttpServletRequest) || !(response instanceof HttpServletResponse)) {
        throw new ServletException("OncePerRequestFilter just supports HTTP requests");
    } 
    HttpServletRequest httpRequest = (HttpServletRequest)request;
    HttpServletResponse httpResponse = (HttpServletResponse)response;
    String alreadyFilteredAttributeName = getAlreadyFilteredAttributeName();
    boolean hasAlreadyFilteredAttribute = request.getAttribute(alreadyFilteredAttributeName) != null;
    if (skipDispatch(httpRequest) || shouldNotFilter(httpRequest)) {
        filterChain.doFilter(request, response);
    } else if (hasAlreadyFilteredAttribute) {
        if (DispatcherType.ERROR.equals(request.getDispatcherType())) {
            doFilterNestedErrorDispatch(httpRequest, httpResponse, filterChain);
            return ;
        } 
        filterChain.doFilter(request, response);
    } else {
        request.setAttribute(alreadyFilteredAttributeName, Boolean.TRUE);
        try {
            doFilterInternal(httpRequest, httpResponse, filterChain);
        } finally {
            request.removeAttribute(alreadyFilteredAttributeName);
        }
    }
}
org.springframework.web.filter.OncePerRequestFilter
protected abstract void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
org.springframework.web.filter.OncePerRequestFilter
protected void doFilterNestedErrorDispatch(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
{
    filterChain.doFilter(request, response);
}
org.springframework.web.filter.OncePerRequestFilter
protected String getAlreadyFilteredAttributeName()
{
    String name = getFilterName();
    if (name == null) {
        name = getClass().getName();
    } 
    return name + ALREADY_FILTERED_SUFFIX;
}
org.springframework.web.filter.OncePerRequestFilter
protected boolean isAsyncDispatch(HttpServletRequest request)
{
    return WebAsyncUtils.getAsyncManager(request).hasConcurrentResult();
}
org.springframework.web.filter.OncePerRequestFilter
protected boolean isAsyncStarted(HttpServletRequest request)
{
    return WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted();
}
org.springframework.web.filter.OncePerRequestFilter
protected boolean shouldNotFilter(HttpServletRequest request)
{
    return false;
}
org.springframework.web.filter.OncePerRequestFilter
protected boolean shouldNotFilterAsyncDispatch()
{
    return true;
}
org.springframework.web.filter.OncePerRequestFilter
protected boolean shouldNotFilterErrorDispatch()
{
    return true;
}
 RelativeRedirectFilter
 extends OncePerRequestFilter
org.springframework.web.filter.RelativeRedirectFilter
@Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
{
    response = RelativeRedirectResponseWrapper.wrapIfNecessary(response, this.redirectStatus);
    filterChain.doFilter(request, response);
}
org.springframework.web.filter.RelativeRedirectFilter
public HttpStatus getRedirectStatus()
{
    return this.redirectStatus;
}
 RelativeRedirectResponseWrapper
 extends HttpServletResponseWrapper
org.springframework.web.filter.RelativeRedirectResponseWrapper
@Override public void sendRedirect(String location)
{
    setStatus(this.redirectStatus.value());
    setHeader(HttpHeaders.LOCATION, location);
}
org.springframework.web.filter.RelativeRedirectResponseWrapper
public static HttpServletResponse wrapIfNecessary(HttpServletResponse response, HttpStatus redirectStatus)
{
    RelativeRedirectResponseWrapper wrapper = WebUtils.getNativeResponse(response, RelativeRedirectResponseWrapper.class);
    return (wrapper != null ? response : new RelativeRedirectResponseWrapper(response, redirectStatus));
}
 RequestContextFilter
 extends OncePerRequestFilter
org.springframework.web.filter.RequestContextFilter
@Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
{
    ServletRequestAttributes attributes = new ServletRequestAttributes(request, response);
    initContextHolders(request, attributes);
    try {
        filterChain.doFilter(request, response);
    } finally {
        resetContextHolders();
        if (logger.isTraceEnabled()) {
            logger.trace("Cleared thread-bound request context: " + request);
        } 
        attributes.requestCompleted();
    }
}
org.springframework.web.filter.RequestContextFilter
public void setThreadContextInheritable(boolean threadContextInheritable)
{
    this.threadContextInheritable = threadContextInheritable;
}
org.springframework.web.filter.RequestContextFilter
@Override protected boolean shouldNotFilterAsyncDispatch()
{
    return false;
}
org.springframework.web.filter.RequestContextFilter
@Override protected boolean shouldNotFilterErrorDispatch()
{
    return false;
}
 ServletContextRequestLoggingFilter
 extends AbstractRequestLoggingFilter
org.springframework.web.filter.ServletContextRequestLoggingFilter
@Override protected void afterRequest(HttpServletRequest request, String message)
{
    getServletContext().log(message);
}
org.springframework.web.filter.ServletContextRequestLoggingFilter
@Override protected void beforeRequest(HttpServletRequest request, String message)
{
    getServletContext().log(message);
}
 ShallowEtagHeaderFilter
 extends OncePerRequestFilter
org.springframework.web.filter.ShallowEtagHeaderFilter
public static void disableContentCaching(ServletRequest request)
{
    Assert.notNull(request, "ServletRequest must not be null");
    request.setAttribute(STREAMING_ATTRIBUTE, true);
}
org.springframework.web.filter.ShallowEtagHeaderFilter
@Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
{
    HttpServletResponse responseToUse = response;
    if (!isAsyncDispatch(request) && !(response instanceof ContentCachingResponseWrapper)) {
        responseToUse = new HttpStreamingAwareContentCachingResponseWrapper(response, request);
    } 
    filterChain.doFilter(request, responseToUse);
    if (!isAsyncStarted(request) && !isContentCachingDisabled(request)) {
        updateResponse(request, responseToUse);
    } 
}
org.springframework.web.filter.ShallowEtagHeaderFilter
protected String generateETagHeaderValue(InputStream inputStream, boolean isWeak)
{
    StringBuilder builder = new StringBuilder(37);
    if (isWeak) {
        builder.append("W/");
    } 
    builder.append("\"0");
    DigestUtils.appendMd5DigestAsHex(inputStream, builder);
    builder.append('"');
    return builder.toString();
}
org.springframework.web.filter.ShallowEtagHeaderFilter
protected boolean isEligibleForEtag(HttpServletRequest request, HttpServletResponse response, int responseStatusCode, InputStream inputStream)
{
    String method = request.getMethod();
    if (responseStatusCode >= 200 && responseStatusCode < 300 && HttpMethod.GET.matches(method)) {
        String cacheControl = response.getHeader(HttpHeaders.CACHE_CONTROL);
        return (cacheControl == null || !cacheControl.contains(DIRECTIVE_NO_STORE));
    } 
    return false;
}
org.springframework.web.filter.ShallowEtagHeaderFilter
public boolean isWriteWeakETag()
{
    return this.writeWeakETag;
}
org.springframework.web.filter.ShallowEtagHeaderFilter
public void setWriteWeakETag(boolean writeWeakETag)
{
    this.writeWeakETag = writeWeakETag;
}
org.springframework.web.filter.ShallowEtagHeaderFilter
@Override protected boolean shouldNotFilterAsyncDispatch()
{
    return false;
}
 ForwardedHeaderFilter
 extends ForwardedHeaderTransformer implements WebFilter
org.springframework.web.filter.reactive.ForwardedHeaderFilter
@Override public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain)
{
    ServerHttpRequest request = exchange.getRequest();
    if (hasForwardedHeaders(request)) {
        exchange = exchange.mutate().request(apply(request)).build();
    } 
    return chain.filter(exchange);
}
 HiddenHttpMethodFilter
 implements WebFilter
org.springframework.web.filter.reactive.HiddenHttpMethodFilter
public static final String DEFAULT_METHOD_PARAMETER_NAME
org.springframework.web.filter.reactive.HiddenHttpMethodFilter
@Override public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain)
{
    if (exchange.getRequest().getMethod() != HttpMethod.POST) {
        return chain.filter(exchange);
    } 
    return exchange.getFormData().map(formData -> {
        String method = formData.getFirst(this.methodParamName);
        return StringUtils.hasLength(method) ? mapExchange(exchange, method) : exchange;
    }).flatMap(chain::filter);
}
org.springframework.web.filter.reactive.HiddenHttpMethodFilter
public void setMethodParamName(String methodParamName)
{
    Assert.hasText(methodParamName, "'methodParamName' must not be empty");
    this.methodParamName = methodParamName;
}
 ServerWebExchangeContextFilter
 implements WebFilter
org.springframework.web.filter.reactive.ServerWebExchangeContextFilter
public static final String EXCHANGE_CONTEXT_ATTRIBUTE
org.springframework.web.filter.reactive.ServerWebExchangeContextFilter
@Override public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain)
{
    return chain.filter(exchange).subscriberContext(cxt -> cxt.put(EXCHANGE_CONTEXT_ATTRIBUTE, exchange));
}
org.springframework.web.filter.reactive.ServerWebExchangeContextFilter
public static Optional<ServerWebExchange> get(Context context)
{
    return context.getOrEmpty(EXCHANGE_CONTEXT_ATTRIBUTE);
}
 DecoratingNavigationHandler
 extends NavigationHandler
org.springframework.web.jsf.DecoratingNavigationHandler
protected DecoratingNavigationHandler DecoratingNavigationHandler()
{
}
org.springframework.web.jsf.DecoratingNavigationHandler
protected DecoratingNavigationHandler DecoratingNavigationHandler(NavigationHandler originalNavigationHandler)
{
    this.decoratedNavigationHandler = originalNavigationHandler;
}
org.springframework.web.jsf.DecoratingNavigationHandler
@Nullable public final NavigationHandler getDecoratedNavigationHandler()
{
    return this.decoratedNavigationHandler;
}
org.springframework.web.jsf.DecoratingNavigationHandler
@Override public final void handleNavigation(FacesContext facesContext, String fromAction, String outcome)
{
    handleNavigation(facesContext, fromAction, outcome, this.decoratedNavigationHandler);
}
org.springframework.web.jsf.DecoratingNavigationHandler
public abstract void handleNavigation(FacesContext facesContext, @Nullable String fromAction, @Nullable String outcome, @Nullable NavigationHandler originalNavigationHandler)
 DelegatingNavigationHandlerProxy
 extends NavigationHandler
org.springframework.web.jsf.DelegatingNavigationHandlerProxy
public static final String DEFAULT_TARGET_BEAN_NAME
org.springframework.web.jsf.DelegatingNavigationHandlerProxy
public DelegatingNavigationHandlerProxy DelegatingNavigationHandlerProxy()
{
}
org.springframework.web.jsf.DelegatingNavigationHandlerProxy
public DelegatingNavigationHandlerProxy DelegatingNavigationHandlerProxy(NavigationHandler originalNavigationHandler)
{
    this.originalNavigationHandler = originalNavigationHandler;
}
org.springframework.web.jsf.DelegatingNavigationHandlerProxy
protected BeanFactory getBeanFactory(FacesContext facesContext)
{
    return getWebApplicationContext(facesContext);
}
org.springframework.web.jsf.DelegatingNavigationHandlerProxy
protected NavigationHandler getDelegate(FacesContext facesContext)
{
    String targetBeanName = getTargetBeanName(facesContext);
    return getBeanFactory(facesContext).getBean(targetBeanName, NavigationHandler.class);
}
org.springframework.web.jsf.DelegatingNavigationHandlerProxy
protected String getTargetBeanName(FacesContext facesContext)
{
    return DEFAULT_TARGET_BEAN_NAME;
}
org.springframework.web.jsf.DelegatingNavigationHandlerProxy
protected WebApplicationContext getWebApplicationContext(FacesContext facesContext)
{
    return FacesContextUtils.getRequiredWebApplicationContext(facesContext);
}
 DelegatingPhaseListenerMulticaster
 implements PhaseListener
org.springframework.web.jsf.DelegatingPhaseListenerMulticaster
@Override public void afterPhase(PhaseEvent event)
{
    for (PhaseListener listener: getDelegates(event.getFacesContext())) {
        listener.afterPhase(event);
    }
}
org.springframework.web.jsf.DelegatingPhaseListenerMulticaster
@Override public void beforePhase(PhaseEvent event)
{
    for (PhaseListener listener: getDelegates(event.getFacesContext())) {
        listener.beforePhase(event);
    }
}
org.springframework.web.jsf.DelegatingPhaseListenerMulticaster
protected ListableBeanFactory getBeanFactory(FacesContext facesContext)
{
    return getWebApplicationContext(facesContext);
}
org.springframework.web.jsf.DelegatingPhaseListenerMulticaster
protected Collection<PhaseListener> getDelegates(FacesContext facesContext)
{
    ListableBeanFactory bf = getBeanFactory(facesContext);
    return BeanFactoryUtils.beansOfTypeIncludingAncestors(bf, PhaseListener.class, true, false).values();
}
org.springframework.web.jsf.DelegatingPhaseListenerMulticaster
@Override public PhaseId getPhaseId()
{
    return PhaseId.ANY_PHASE;
}
org.springframework.web.jsf.DelegatingPhaseListenerMulticaster
protected WebApplicationContext getWebApplicationContext(FacesContext facesContext)
{
    return FacesContextUtils.getRequiredWebApplicationContext(facesContext);
}
 FacesContextUtils
org.springframework.web.jsf.FacesContextUtils
public static WebApplicationContext getRequiredWebApplicationContext(FacesContext fc)
{
    WebApplicationContext wac = getWebApplicationContext(fc);
    if (wac == null) {
        throw new IllegalStateException("No WebApplicationContext found: no ContextLoaderListener registered?");
    } 
    return wac;
}
org.springframework.web.jsf.FacesContextUtils
@Nullable public static WebApplicationContext getWebApplicationContext(FacesContext fc)
{
    Assert.notNull(fc, "FacesContext must not be null");
    Object attr = fc.getExternalContext().getApplicationMap().get(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
    if (attr == null) {
        return null;
    } 
    if (attr instanceof RuntimeException) {
        throw (RuntimeException)attr;
    } 
    if (attr instanceof Error) {
        throw (Error)attr;
    } 
    if (!(attr instanceof WebApplicationContext)) {
        throw new IllegalStateException("Root context attribute is not of type WebApplicationContext: " + attr);
    } 
    return (WebApplicationContext)attr;
}
 SpringBeanFacesELResolver
 extends ELResolver
org.springframework.web.jsf.el.SpringBeanFacesELResolver
@Override public Class<?> getCommonPropertyType(ELContext elContext, @Nullable Object base)
{
    return Object.class;
}
org.springframework.web.jsf.el.SpringBeanFacesELResolver
@Override @Nullable public Iterator<FeatureDescriptor> getFeatureDescriptors(ELContext elContext, @Nullable Object base)
{
    return null;
}
org.springframework.web.jsf.el.SpringBeanFacesELResolver
@Override @Nullable public Class<?> getType(ELContext elContext, @Nullable Object base, Object property)
{
    if (base == null) {
        String beanName = property.toString();
        WebApplicationContext wac = getWebApplicationContext(elContext);
        if (wac.containsBean(beanName)) {
            elContext.setPropertyResolved(true);
            return wac.getType(beanName);
        } 
    } 
    return null;
}
org.springframework.web.jsf.el.SpringBeanFacesELResolver
@Override @Nullable public Object getValue(ELContext elContext, @Nullable Object base, Object property)
{
    if (base == null) {
        String beanName = property.toString();
        WebApplicationContext wac = getWebApplicationContext(elContext);
        if (wac.containsBean(beanName)) {
            elContext.setPropertyResolved(true);
            return wac.getBean(beanName);
        } 
    } 
    return null;
}
org.springframework.web.jsf.el.SpringBeanFacesELResolver
protected WebApplicationContext getWebApplicationContext(ELContext elContext)
{
    FacesContext facesContext = FacesContext.getCurrentInstance();
    return FacesContextUtils.getRequiredWebApplicationContext(facesContext);
}
org.springframework.web.jsf.el.SpringBeanFacesELResolver
@Override public boolean isReadOnly(ELContext elContext, @Nullable Object base, Object property)
{
    if (base == null) {
        String beanName = property.toString();
        WebApplicationContext wac = getWebApplicationContext(elContext);
        if (wac.containsBean(beanName)) {
            return true;
        } 
    } 
    return false;
}
 WebApplicationContextFacesELResolver
 extends ELResolver
org.springframework.web.jsf.el.WebApplicationContextFacesELResolver
public static final String WEB_APPLICATION_CONTEXT_VARIABLE_NAME
org.springframework.web.jsf.el.WebApplicationContextFacesELResolver
@Override public Class<?> getCommonPropertyType(ELContext elContext, Object base)
{
    return Object.class;
}
org.springframework.web.jsf.el.WebApplicationContextFacesELResolver
@Override @Nullable public Iterator<FeatureDescriptor> getFeatureDescriptors(ELContext elContext, Object base)
{
    return null;
}
org.springframework.web.jsf.el.WebApplicationContextFacesELResolver
@Nullable protected WebApplicationContext getWebApplicationContext(ELContext elContext)
{
    FacesContext facesContext = FacesContext.getCurrentInstance();
    return FacesContextUtils.getRequiredWebApplicationContext(facesContext);
}
org.springframework.web.jsf.el.WebApplicationContextFacesELResolver
@Override public boolean isReadOnly(ELContext elContext, Object base, Object property)
{
    if (base instanceof WebApplicationContext) {
        elContext.setPropertyResolved(true);
        return true;
    } 
    return false;
}
org.springframework.web.jsf.el.WebApplicationContextFacesELResolver
protected final Log logger
org.springframework.web.jsf.el.WebApplicationContextFacesELResolver
@Override public void setValue(ELContext elContext, Object base, Object property, Object value)
{
}
 ControllerAdviceBean
 implements Ordered
org.springframework.web.method.ControllerAdviceBean
public ControllerAdviceBean ControllerAdviceBean(String beanName, BeanFactory beanFactory)
{
    this(beanName, beanFactory, null);
}
org.springframework.web.method.ControllerAdviceBean
@Override public boolean equals(@Nullable Object other)
{
    if (this == other) {
        return true;
    } 
    if (!(other instanceof ControllerAdviceBean)) {
        return false;
    } 
    ControllerAdviceBean otherAdvice = (ControllerAdviceBean)other;
    return (this.beanOrName.equals(otherAdvice.beanOrName) && this.beanFactory == otherAdvice.beanFactory);
}
org.springframework.web.method.ControllerAdviceBean
@Nullable public Class<?> getBeanType()
{
    return this.beanType;
}
org.springframework.web.method.ControllerAdviceBean
@Override public int hashCode()
{
    return this.beanOrName.hashCode();
}
org.springframework.web.method.ControllerAdviceBean
public boolean isApplicableToBeanType(@Nullable Class<?> beanType)
{
    return this.beanTypePredicate.test(beanType);
}
org.springframework.web.method.ControllerAdviceBean
public Object resolveBean()
{
    if (this.resolvedBean == null) {
        this.resolvedBean = obtainBeanFactory().getBean((String)this.beanOrName);
    } 
    return this.resolvedBean;
}
org.springframework.web.method.ControllerAdviceBean
@Override public String toString()
{
    return this.beanOrName.toString();
}
 HandlerMethod
org.springframework.web.method.HandlerMethod
public HandlerMethod HandlerMethod(String beanName, BeanFactory beanFactory, Method method)
{
    Assert.hasText(beanName, "Bean name is required");
    Assert.notNull(beanFactory, "BeanFactory is required");
    Assert.notNull(method, "Method is required");
    this.bean = beanName;
    this.beanFactory = beanFactory;
    Class<?> beanType = beanFactory.getType(beanName);
    if (beanType == null) {
        throw new IllegalStateException("Cannot resolve bean type for bean with name '" + beanName + "'");
    } 
    this.beanType = ClassUtils.getUserClass(beanType);
    this.method = method;
    this.bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
    this.parameters = initMethodParameters();
    evaluateResponseStatus();
    this.description = initDescription(this.beanType, this.method);
}
 HandlerMethodParameter
 extends SynthesizingMethodParameter
org.springframework.web.method.HandlerMethod.HandlerMethodParameter
public HandlerMethodParameter HandlerMethodParameter(int index)
{
    super(HandlerMethod.this.bridgedMethod, index);
}
org.springframework.web.method.HandlerMethod.HandlerMethodParameter
protected HandlerMethodParameter HandlerMethodParameter(HandlerMethodParameter original)
{
    super(original);
}
org.springframework.web.method.HandlerMethod.HandlerMethodParameter
@Override public HandlerMethodParameter clone()
{
    return new HandlerMethodParameter(this);
}
org.springframework.web.method.HandlerMethod.HandlerMethodParameter
@Nullable volatile Annotation[] combinedAnnotations
org.springframework.web.method.HandlerMethod.HandlerMethodParameter
@Override public Class<?> getContainingClass()
{
    return HandlerMethod.this.getBeanType();
}
org.springframework.web.method.HandlerMethod.HandlerMethodParameter
<T>@Override public T getMethodAnnotation(Class<T> annotationType)
{
    return HandlerMethod.this.getMethodAnnotation(annotationType);
}
org.springframework.web.method.HandlerMethod.HandlerMethodParameter
<T>@Override public boolean hasMethodAnnotation(Class<T> annotationType)
{
    return HandlerMethod.this.hasMethodAnnotation(annotationType);
}
org.springframework.web.method.HandlerMethod
@Override public boolean equals(@Nullable Object other)
{
    if (this == other) {
        return true;
    } 
    if (!(other instanceof HandlerMethod)) {
        return false;
    } 
    HandlerMethod otherMethod = (HandlerMethod)other;
    return (this.bean.equals(otherMethod.bean) && this.method.equals(otherMethod.method));
}
org.springframework.web.method.HandlerMethod
@Nullable protected static Object findProvidedArgument(MethodParameter parameter, @Nullable Object... providedArgs)
{
    if (!ObjectUtils.isEmpty(providedArgs)) {
        for (Object providedArg: providedArgs) {
            if (parameter.getParameterType().isInstance(providedArg)) {
                return providedArg;
            } 
        }
    } 
    return null;
}
org.springframework.web.method.HandlerMethod
protected static String formatArgumentError(MethodParameter param, String message)
{
    return "Could not resolve parameter [" + param.getParameterIndex() + "] in " + param.getExecutable().toGenericString() + (StringUtils.hasText(message) ? ": " + message : "");
}
org.springframework.web.method.HandlerMethod
public Object getBean()
{
    return this.bean;
}
org.springframework.web.method.HandlerMethod
public Class<?> getBeanType()
{
    return this.beanType;
}
org.springframework.web.method.HandlerMethod
protected Method getBridgedMethod()
{
    return this.bridgedMethod;
}
org.springframework.web.method.HandlerMethod
public Method getMethod()
{
    return this.method;
}
org.springframework.web.method.HandlerMethod
<A>@Nullable public A getMethodAnnotation(Class<A> annotationType)
{
    return AnnotatedElementUtils.findMergedAnnotation(this.method, annotationType);
}
org.springframework.web.method.HandlerMethod
public MethodParameter[] getMethodParameters()
{
    return this.parameters;
}
org.springframework.web.method.HandlerMethod
@Nullable public HandlerMethod getResolvedFromHandlerMethod()
{
    return this.resolvedFromHandlerMethod;
}
org.springframework.web.method.HandlerMethod
@Nullable protected HttpStatus getResponseStatus()
{
    return this.responseStatus;
}
org.springframework.web.method.HandlerMethod
@Nullable protected String getResponseStatusReason()
{
    return this.responseStatusReason;
}
org.springframework.web.method.HandlerMethod
public MethodParameter getReturnType()
{
    return new HandlerMethodParameter(-1);
}
org.springframework.web.method.HandlerMethod
public MethodParameter getReturnValueType(@Nullable Object returnValue)
{
    return new ReturnValueMethodParameter(returnValue);
}
org.springframework.web.method.HandlerMethod
public String getShortLogMessage()
{
    return getBeanType().getName() + "#" + this.method.getName() + "[" + this.method.getParameterCount() + " args]";
}
org.springframework.web.method.HandlerMethod
<A>public boolean hasMethodAnnotation(Class<A> annotationType)
{
    return AnnotatedElementUtils.hasAnnotation(this.method, annotationType);
}
org.springframework.web.method.HandlerMethod
@Override public int hashCode()
{
    return (this.bean.hashCode() * 31 + this.method.hashCode());
}
org.springframework.web.method.HandlerMethod
@Nullable volatile List<Annotation[]> interfaceParameterAnnotations
org.springframework.web.method.HandlerMethod
public boolean isVoid()
{
    return Void.TYPE.equals(getReturnType().getParameterType());
}
org.springframework.web.method.HandlerMethod
protected final Log logger
org.springframework.web.method.HandlerMethod
@Override public String toString()
{
    return this.description;
}
 HandlerTypePredicate
 implements Predicate<Class<?>>
 Builder
org.springframework.web.method.HandlerTypePredicate.Builder
@SuppressWarnings("unchecked") public final Builder annotation(Class<?>... annotations)
{
    this.annotations.addAll(Arrays.asList(annotations));
    return this;
}
org.springframework.web.method.HandlerTypePredicate.Builder
public Builder assignableType(Class<?>... types)
{
    this.assignableTypes.addAll(Arrays.asList(types));
    return this;
}
org.springframework.web.method.HandlerTypePredicate.Builder
public Builder basePackage(String... packages)
{
    Arrays.stream(packages).filter(StringUtils::hasText).forEach(this::addBasePackage);
    return this;
}
org.springframework.web.method.HandlerTypePredicate.Builder
public Builder basePackageClass(Class<?>... packageClasses)
{
    Arrays.stream(packageClasses).forEach(clazz -> addBasePackage(ClassUtils.getPackageName(clazz)));
    return this;
}
org.springframework.web.method.HandlerTypePredicate.Builder
public HandlerTypePredicate build()
{
    return new HandlerTypePredicate(this.basePackages, this.assignableTypes, this.annotations);
}
org.springframework.web.method.HandlerTypePredicate
public static Builder builder()
{
    return new Builder();
}
org.springframework.web.method.HandlerTypePredicate
@SafeVarargs public static HandlerTypePredicate forAnnotation(Class<?>... annotations)
{
    return new Builder().annotation(annotations).build();
}
org.springframework.web.method.HandlerTypePredicate
public static HandlerTypePredicate forAnyHandlerType()
{
    return new HandlerTypePredicate(Collections.emptySet(), Collections.emptyList(), Collections.emptyList());
}
org.springframework.web.method.HandlerTypePredicate
public static HandlerTypePredicate forAssignableType(Class<?>... types)
{
    return new Builder().assignableType(types).build();
}
org.springframework.web.method.HandlerTypePredicate
public static HandlerTypePredicate forBasePackage(String... packages)
{
    return new Builder().basePackage(packages).build();
}
org.springframework.web.method.HandlerTypePredicate
public static HandlerTypePredicate forBasePackageClass(Class<?>... packageClasses)
{
    return new Builder().basePackageClass(packageClasses).build();
}
org.springframework.web.method.HandlerTypePredicate
@Override public boolean test(Class<?> controllerType)
{
    if (!hasSelectors()) {
        return true;
    } else if (controllerType != null) {
        for (String basePackage: this.basePackages) {
            if (controllerType.getName().startsWith(basePackage)) {
                return true;
            } 
        }
        for (Class<?> clazz: this.assignableTypes) {
            if (ClassUtils.isAssignable(clazz, controllerType)) {
                return true;
            } 
        }
        for (Class<? extends Annotation> annotationClass: this.annotations) {
            if (AnnotationUtils.findAnnotation(controllerType, annotationClass) != null) {
                return true;
            } 
        }
    } 
    return false;
}
 AbstractCookieValueMethodArgumentResolver
 extends AbstractNamedValueMethodArgumentResolver
org.springframework.web.method.annotation.AbstractCookieValueMethodArgumentResolver
public AbstractCookieValueMethodArgumentResolver AbstractCookieValueMethodArgumentResolver(@Nullable ConfigurableBeanFactory beanFactory)
{
    super(beanFactory);
}
org.springframework.web.method.annotation.AbstractCookieValueMethodArgumentResolver
@Override protected NamedValueInfo createNamedValueInfo(MethodParameter parameter)
{
    CookieValue annotation = parameter.getParameterAnnotation(CookieValue.class);
    Assert.state(annotation != null, "No CookieValue annotation");
    return new CookieValueNamedValueInfo(annotation);
}
org.springframework.web.method.annotation.AbstractCookieValueMethodArgumentResolver
@Override protected void handleMissingValue(String name, MethodParameter parameter)
{
    throw new MissingRequestCookieException(name, parameter);
}
org.springframework.web.method.annotation.AbstractCookieValueMethodArgumentResolver
@Override public boolean supportsParameter(MethodParameter parameter)
{
    return parameter.hasParameterAnnotation(CookieValue.class);
}
 AbstractNamedValueMethodArgumentResolver
 implements HandlerMethodArgumentResolver
org.springframework.web.method.annotation.AbstractNamedValueMethodArgumentResolver
public AbstractNamedValueMethodArgumentResolver AbstractNamedValueMethodArgumentResolver()
{
    this.configurableBeanFactory = null;
    this.expressionContext = null;
}
org.springframework.web.method.annotation.AbstractNamedValueMethodArgumentResolver
public AbstractNamedValueMethodArgumentResolver AbstractNamedValueMethodArgumentResolver(@Nullable ConfigurableBeanFactory beanFactory)
{
    this.configurableBeanFactory = beanFactory;
    this.expressionContext = (beanFactory != null ? new BeanExpressionContext(beanFactory, new RequestScope()) : null);
}
 NamedValueInfo
org.springframework.web.method.annotation.AbstractNamedValueMethodArgumentResolver.NamedValueInfo
public NamedValueInfo NamedValueInfo(String name, boolean required, @Nullable String defaultValue)
{
    this.name = name;
    this.required = required;
    this.defaultValue = defaultValue;
}
org.springframework.web.method.annotation.AbstractNamedValueMethodArgumentResolver
protected abstract NamedValueInfo createNamedValueInfo(MethodParameter parameter)
org.springframework.web.method.annotation.AbstractNamedValueMethodArgumentResolver
protected void handleMissingValue(String name, MethodParameter parameter, NativeWebRequest request)
{
    handleMissingValue(name, parameter);
}
org.springframework.web.method.annotation.AbstractNamedValueMethodArgumentResolver
protected void handleMissingValue(String name, MethodParameter parameter)
{
    throw new ServletRequestBindingException("Missing argument '" + name + "' for method parameter of type " + parameter.getNestedParameterType().getSimpleName());
}
org.springframework.web.method.annotation.AbstractNamedValueMethodArgumentResolver
protected void handleResolvedValue(@Nullable Object arg, String name, MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest)
{
}
org.springframework.web.method.annotation.AbstractNamedValueMethodArgumentResolver
@Override @Nullable public final Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory)
{
    NamedValueInfo namedValueInfo = getNamedValueInfo(parameter);
    MethodParameter nestedParameter = parameter.nestedIfOptional();
    Object resolvedName = resolveStringValue(namedValueInfo.name);
    if (resolvedName == null) {
        throw new IllegalArgumentException("Specified name must not resolve to null: [" + namedValueInfo.name + "]");
    } 
    Object arg = resolveName(resolvedName.toString(), nestedParameter, webRequest);
    if (arg == null) {
        if (namedValueInfo.defaultValue != null) {
            arg = resolveStringValue(namedValueInfo.defaultValue);
        } else if (namedValueInfo.required && !nestedParameter.isOptional()) {
            handleMissingValue(namedValueInfo.name, nestedParameter, webRequest);
        } 
        arg = handleNullValue(namedValueInfo.name, arg, nestedParameter.getNestedParameterType());
    } else if ("".equals(arg) && namedValueInfo.defaultValue != null) {
        arg = resolveStringValue(namedValueInfo.defaultValue);
    } 
    if (binderFactory != null) {
        WebDataBinder binder = binderFactory.createBinder(webRequest, null, namedValueInfo.name);
        try {
            arg = binder.convertIfNecessary(arg, parameter.getParameterType(), parameter);
        } catch (ConversionNotSupportedException ex) {
            throw new MethodArgumentConversionNotSupportedException(arg, ex.getRequiredType(), namedValueInfo.name, parameter, ex.getCause());
        } catch (TypeMismatchException ex) {
            throw new MethodArgumentTypeMismatchException(arg, ex.getRequiredType(), namedValueInfo.name, parameter, ex.getCause());
        }
    } 
    handleResolvedValue(arg, namedValueInfo.name, parameter, mavContainer, webRequest);
    return arg;
}
org.springframework.web.method.annotation.AbstractNamedValueMethodArgumentResolver
@Nullable protected abstract Object resolveName(String name, MethodParameter parameter, NativeWebRequest request)
 AbstractWebArgumentResolverAdapter
 implements HandlerMethodArgumentResolver
org.springframework.web.method.annotation.AbstractWebArgumentResolverAdapter
public AbstractWebArgumentResolverAdapter AbstractWebArgumentResolverAdapter(WebArgumentResolver adaptee)
{
    Assert.notNull(adaptee, "'adaptee' must not be null");
    this.adaptee = adaptee;
}
org.springframework.web.method.annotation.AbstractWebArgumentResolverAdapter
protected abstract NativeWebRequest getWebRequest()
 ErrorsMethodArgumentResolver
 implements HandlerMethodArgumentResolver
org.springframework.web.method.annotation.ErrorsMethodArgumentResolver
@Override @Nullable public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory)
{
    Assert.state(mavContainer != null, "Errors/BindingResult argument only supported on regular handler methods");
    ModelMap model = mavContainer.getModel();
    String lastKey = CollectionUtils.lastElement(model.keySet());
    if (lastKey != null && lastKey.startsWith(BindingResult.MODEL_KEY_PREFIX)) {
        return model.get(lastKey);
    } 
    throw new IllegalStateException("An Errors/BindingResult argument is expected to be declared immediately after " + "the model attribute, the @RequestBody or the @RequestPart arguments " + "to which they apply: " + parameter.getMethod());
}
org.springframework.web.method.annotation.ErrorsMethodArgumentResolver
@Override public boolean supportsParameter(MethodParameter parameter)
{
    Class<?> paramType = parameter.getParameterType();
    return Errors.class.isAssignableFrom(paramType);
}
 ExceptionHandlerMethodResolver
org.springframework.web.method.annotation.ExceptionHandlerMethodResolver
public static final MethodFilter EXCEPTION_HANDLER_METHODS
org.springframework.web.method.annotation.ExceptionHandlerMethodResolver
public ExceptionHandlerMethodResolver ExceptionHandlerMethodResolver(Class<?> handlerType)
{
    for (Method method: MethodIntrospector.selectMethods(handlerType, EXCEPTION_HANDLER_METHODS)) {
        for (Class<? extends Throwable> exceptionType: detectExceptionMappings(method)) {
            addExceptionMapping(exceptionType, method);
        }
    }
}
org.springframework.web.method.annotation.ExceptionHandlerMethodResolver
public boolean hasExceptionMappings()
{
    return !this.mappedMethods.isEmpty();
}
org.springframework.web.method.annotation.ExceptionHandlerMethodResolver
@Nullable public Method resolveMethod(Exception exception)
{
    return resolveMethodByThrowable(exception);
}
org.springframework.web.method.annotation.ExceptionHandlerMethodResolver
@Nullable public Method resolveMethodByExceptionType(Class<?> exceptionType)
{
    Method method = this.exceptionLookupCache.get(exceptionType);
    if (method == null) {
        method = getMappedMethod(exceptionType);
        this.exceptionLookupCache.put(exceptionType, method);
    } 
    return method;
}
org.springframework.web.method.annotation.ExceptionHandlerMethodResolver
@Nullable public Method resolveMethodByThrowable(Throwable exception)
{
    Method method = resolveMethodByExceptionType(exception.getClass());
    if (method == null) {
        Throwable cause = exception.getCause();
        if (cause != null) {
            method = resolveMethodByExceptionType(cause.getClass());
        } 
    } 
    return method;
}
 ExpressionValueMethodArgumentResolver
 extends AbstractNamedValueMethodArgumentResolver
org.springframework.web.method.annotation.ExpressionValueMethodArgumentResolver
public ExpressionValueMethodArgumentResolver ExpressionValueMethodArgumentResolver(@Nullable ConfigurableBeanFactory beanFactory)
{
    super(beanFactory);
}
org.springframework.web.method.annotation.ExpressionValueMethodArgumentResolver
@Override protected NamedValueInfo createNamedValueInfo(MethodParameter parameter)
{
    Value ann = parameter.getParameterAnnotation(Value.class);
    Assert.state(ann != null, "No Value annotation");
    return new ExpressionValueNamedValueInfo(ann);
}
org.springframework.web.method.annotation.ExpressionValueMethodArgumentResolver
@Override protected void handleMissingValue(String name, MethodParameter parameter)
{
    throw new UnsupportedOperationException("@Value is never required: " + parameter.getMethod());
}
org.springframework.web.method.annotation.ExpressionValueMethodArgumentResolver
@Override @Nullable protected Object resolveName(String name, MethodParameter parameter, NativeWebRequest webRequest)
{
    return null;
}
org.springframework.web.method.annotation.ExpressionValueMethodArgumentResolver
@Override public boolean supportsParameter(MethodParameter parameter)
{
    return parameter.hasParameterAnnotation(Value.class);
}
 InitBinderDataBinderFactory
 extends DefaultDataBinderFactory
org.springframework.web.method.annotation.InitBinderDataBinderFactory
public InitBinderDataBinderFactory InitBinderDataBinderFactory(@Nullable List<InvocableHandlerMethod> binderMethods, @Nullable WebBindingInitializer initializer)
{
    super(initializer);
    this.binderMethods = (binderMethods != null ? binderMethods : Collections.emptyList());
}
 MapMethodProcessor
 implements HandlerMethodArgumentResolver, HandlerMethodReturnValueHandler
org.springframework.web.method.annotation.MapMethodProcessor
@Override @SuppressWarnings({"rawtypes","unchecked"}) public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest)
{
    if (returnValue instanceof Map) {
        mavContainer.addAllAttributes((Map)returnValue);
    } else if (returnValue != null) {
        throw new UnsupportedOperationException("Unexpected return type: " + returnType.getParameterType().getName() + " in method: " + returnType.getMethod());
    } 
}
org.springframework.web.method.annotation.MapMethodProcessor
@Override @Nullable public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory)
{
    Assert.state(mavContainer != null, "ModelAndViewContainer is required for model exposure");
    return mavContainer.getModel();
}
org.springframework.web.method.annotation.MapMethodProcessor
@Override public boolean supportsParameter(MethodParameter parameter)
{
    return Map.class.isAssignableFrom(parameter.getParameterType()) && parameter.getParameterAnnotations().length == 0;
}
org.springframework.web.method.annotation.MapMethodProcessor
@Override public boolean supportsReturnType(MethodParameter returnType)
{
    return Map.class.isAssignableFrom(returnType.getParameterType());
}
 MethodArgumentConversionNotSupportedException
 extends ConversionNotSupportedException
org.springframework.web.method.annotation.MethodArgumentConversionNotSupportedException
public MethodArgumentConversionNotSupportedException MethodArgumentConversionNotSupportedException(@Nullable Object value, @Nullable Class<?> requiredType, String name, MethodParameter param, Throwable cause)
{
    super(value, requiredType, cause);
    this.name = name;
    this.parameter = param;
}
org.springframework.web.method.annotation.MethodArgumentConversionNotSupportedException
public String getName()
{
    return this.name;
}
org.springframework.web.method.annotation.MethodArgumentConversionNotSupportedException
public MethodParameter getParameter()
{
    return this.parameter;
}
 MethodArgumentTypeMismatchException
 extends TypeMismatchException
org.springframework.web.method.annotation.MethodArgumentTypeMismatchException
public MethodArgumentTypeMismatchException MethodArgumentTypeMismatchException(@Nullable Object value, @Nullable Class<?> requiredType, String name, MethodParameter param, Throwable cause)
{
    super(value, requiredType, cause);
    this.name = name;
    this.parameter = param;
}
org.springframework.web.method.annotation.MethodArgumentTypeMismatchException
public String getName()
{
    return this.name;
}
org.springframework.web.method.annotation.MethodArgumentTypeMismatchException
public MethodParameter getParameter()
{
    return this.parameter;
}
 ModelAttributeMethodProcessor
 implements HandlerMethodArgumentResolver, HandlerMethodReturnValueHandler
org.springframework.web.method.annotation.ModelAttributeMethodProcessor
public ModelAttributeMethodProcessor ModelAttributeMethodProcessor(boolean annotationNotRequired)
{
    this.annotationNotRequired = annotationNotRequired;
}
org.springframework.web.method.annotation.ModelAttributeMethodProcessor
protected void bindRequestParameters(WebDataBinder binder, NativeWebRequest request)
{
    ((WebRequestDataBinder)binder).bind(request);
}
org.springframework.web.method.annotation.ModelAttributeMethodProcessor
@SuppressWarnings("deprecation") protected Object constructAttribute(Constructor<?> ctor, String attributeName, MethodParameter parameter, WebDataBinderFactory binderFactory, NativeWebRequest webRequest)
{
    Object constructed = constructAttribute(ctor, attributeName, binderFactory, webRequest);
    if (constructed != null) {
        return constructed;
    } 
    if (ctor.getParameterCount() == 0) {
        return BeanUtils.instantiateClass(ctor);
    } 
    ConstructorProperties cp = ctor.getAnnotation(ConstructorProperties.class);
    String[] paramNames = (cp != null ? cp.value() : parameterNameDiscoverer.getParameterNames(ctor));
    Assert.state(paramNames != null, () -> "Cannot resolve parameter names for constructor " + ctor);
    Class<?>[] paramTypes = ctor.getParameterTypes();
    Assert.state(paramNames.length == paramTypes.length, () -> "Invalid number of parameter names: " + paramNames.length + " for constructor " + ctor);
    Object[] args = new Object[paramTypes.length];
    WebDataBinder binder = binderFactory.createBinder(webRequest, null, attributeName);
    String fieldDefaultPrefix = binder.getFieldDefaultPrefix();
    String fieldMarkerPrefix = binder.getFieldMarkerPrefix();
    boolean bindingFailure = false;
    Set<String> failedParams = new HashSet<>(4);
    for (int i = 0; i < paramNames.length; i++) {
        String paramName = paramNames[i];
        Class<?> paramType = paramTypes[i];
        Object value = webRequest.getParameterValues(paramName);
        if (value == null) {
            if (fieldDefaultPrefix != null) {
                value = webRequest.getParameter(fieldDefaultPrefix + paramName);
            } 
            if (value == null && fieldMarkerPrefix != null) {
                if (webRequest.getParameter(fieldMarkerPrefix + paramName) != null) {
                    value = binder.getEmptyValue(paramType);
                } 
            } 
        } 
        try {
            MethodParameter methodParam = new FieldAwareConstructorParameter(ctor, i, paramName);
            if (value == null && methodParam.isOptional()) {
                args[i] = (methodParam.getParameterType() == Optional.class ? Optional.empty() : null);
            } else {
                args[i] = binder.convertIfNecessary(value, paramType, methodParam);
            }
        } catch (TypeMismatchException ex) {
            ex.initPropertyName(paramName);
            args[i] = value;
            failedParams.add(paramName);
            binder.getBindingResult().recordFieldValue(paramName, paramType, value);
            binder.getBindingErrorProcessor().processPropertyAccessException(ex, binder.getBindingResult());
            bindingFailure = true;
        }
    }
    if (bindingFailure) {
        BindingResult result = binder.getBindingResult();
        for (int i = 0; i < paramNames.length; i++) {
            String paramName = paramNames[i];
            if (!failedParams.contains(paramName)) {
                Object value = args[i];
                result.recordFieldValue(paramName, paramTypes[i], value);
                validateValueIfApplicable(binder, parameter, ctor.getDeclaringClass(), paramName, value);
            } 
        }
        throw new BindException(result);
    } 
    return BeanUtils.instantiateClass(ctor, args);
}
org.springframework.web.method.annotation.ModelAttributeMethodProcessor
@Deprecated @Nullable protected Object constructAttribute(Constructor<?> ctor, String attributeName, WebDataBinderFactory binderFactory, NativeWebRequest webRequest)
{
    return null;
}
org.springframework.web.method.annotation.ModelAttributeMethodProcessor
protected Object createAttribute(String attributeName, MethodParameter parameter, WebDataBinderFactory binderFactory, NativeWebRequest webRequest)
{
    MethodParameter nestedParameter = parameter.nestedIfOptional();
    Class<?> clazz = nestedParameter.getNestedParameterType();
    Constructor<?> ctor = BeanUtils.findPrimaryConstructor(clazz);
    if (ctor == null) {
        Constructor<?>[] ctors = clazz.getConstructors();
        if (ctors.length == 1) {
            ctor = ctors[0];
        } else {
            try {
                ctor = clazz.getDeclaredConstructor();
            } catch (NoSuchMethodException ex) {
                throw new IllegalStateException("No primary or default constructor found for " + clazz, ex);
            }
        }
    } 
    Object attribute = constructAttribute(ctor, attributeName, parameter, binderFactory, webRequest);
    if (parameter != nestedParameter) {
        attribute = Optional.of(attribute);
    } 
    return attribute;
}
org.springframework.web.method.annotation.ModelAttributeMethodProcessor
@Override public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest)
{
    if (returnValue != null) {
        String name = ModelFactory.getNameForReturnValue(returnValue, returnType);
        mavContainer.addAttribute(name, returnValue);
    } 
}
org.springframework.web.method.annotation.ModelAttributeMethodProcessor
protected boolean isBindExceptionRequired(WebDataBinder binder, MethodParameter parameter)
{
    return isBindExceptionRequired(parameter);
}
org.springframework.web.method.annotation.ModelAttributeMethodProcessor
protected final Log logger
org.springframework.web.method.annotation.ModelAttributeMethodProcessor
@Override @Nullable public final Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory)
{
    Assert.state(mavContainer != null, "ModelAttributeMethodProcessor requires ModelAndViewContainer");
    Assert.state(binderFactory != null, "ModelAttributeMethodProcessor requires WebDataBinderFactory");
    String name = ModelFactory.getNameForParameter(parameter);
    ModelAttribute ann = parameter.getParameterAnnotation(ModelAttribute.class);
    if (ann != null) {
        mavContainer.setBinding(name, ann.binding());
    } 
    Object attribute = null;
    BindingResult bindingResult = null;
    if (mavContainer.containsAttribute(name)) {
        attribute = mavContainer.getModel().get(name);
    } else {
        try {
            attribute = createAttribute(name, parameter, binderFactory, webRequest);
        } catch (BindException ex) {
            if (isBindExceptionRequired(parameter)) {
                throw ex;
            } 
            if (parameter.getParameterType() == Optional.class) {
                attribute = Optional.empty();
            } 
            bindingResult = ex.getBindingResult();
        }
    }
    if (bindingResult == null) {
        WebDataBinder binder = binderFactory.createBinder(webRequest, attribute, name);
        if (binder.getTarget() != null) {
            if (!mavContainer.isBindingDisabled(name)) {
                bindRequestParameters(binder, webRequest);
            } 
            validateIfApplicable(binder, parameter);
            if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
                throw new BindException(binder.getBindingResult());
            } 
        } 
        if (!parameter.getParameterType().isInstance(attribute)) {
            attribute = binder.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter);
        } 
        bindingResult = binder.getBindingResult();
    } 
    Map<String, Object> bindingResultModel = bindingResult.getModel();
    mavContainer.removeAttributes(bindingResultModel);
    mavContainer.addAllAttributes(bindingResultModel);
    return attribute;
}
org.springframework.web.method.annotation.ModelAttributeMethodProcessor
@Override public boolean supportsParameter(MethodParameter parameter)
{
    return (parameter.hasParameterAnnotation(ModelAttribute.class) || (this.annotationNotRequired && !BeanUtils.isSimpleProperty(parameter.getParameterType())));
}
org.springframework.web.method.annotation.ModelAttributeMethodProcessor
@Override public boolean supportsReturnType(MethodParameter returnType)
{
    return (returnType.hasMethodAnnotation(ModelAttribute.class) || (this.annotationNotRequired && !BeanUtils.isSimpleProperty(returnType.getParameterType())));
}
org.springframework.web.method.annotation.ModelAttributeMethodProcessor
protected void validateIfApplicable(WebDataBinder binder, MethodParameter parameter)
{
    for (Annotation ann: parameter.getParameterAnnotations()) {
        Object[] validationHints = determineValidationHints(ann);
        if (validationHints != null) {
            binder.validate(validationHints);
            break;
        } 
    }
}
org.springframework.web.method.annotation.ModelAttributeMethodProcessor
protected void validateValueIfApplicable(WebDataBinder binder, MethodParameter parameter, Class<?> targetType, String fieldName, @Nullable Object value)
{
    for (Annotation ann: parameter.getParameterAnnotations()) {
        Object[] validationHints = determineValidationHints(ann);
        if (validationHints != null) {
            for (Validator validator: binder.getValidators()) {
                if (validator instanceof SmartValidator) {
                    try {
                        ((SmartValidator)validator).validateValue(targetType, fieldName, value, binder.getBindingResult(), validationHints);
                    } catch (IllegalArgumentException ex) {
                    }
                } 
            }
            break;
        } 
    }
}
 ModelFactory
org.springframework.web.method.annotation.ModelFactory
public ModelFactory ModelFactory(@Nullable List<InvocableHandlerMethod> handlerMethods, WebDataBinderFactory binderFactory, SessionAttributesHandler attributeHandler)
{
    if (handlerMethods != null) {
        for (InvocableHandlerMethod handlerMethod: handlerMethods) {
            this.modelMethods.add(new ModelMethod(handlerMethod));
        }
    } 
    this.dataBinderFactory = binderFactory;
    this.sessionAttributesHandler = attributeHandler;
}
org.springframework.web.method.annotation.ModelFactory
public void updateModel(NativeWebRequest request, ModelAndViewContainer container)
{
    ModelMap defaultModel = container.getDefaultModel();
    if (container.getSessionStatus().isComplete()) {
        this.sessionAttributesHandler.cleanupAttributes(request);
    } else {
        this.sessionAttributesHandler.storeAttributes(request, defaultModel);
    }
    if (!container.isRequestHandled() && container.getModel() == defaultModel) {
        updateBindingResult(request, defaultModel);
    } 
}
 ModelMethodProcessor
 implements HandlerMethodArgumentResolver, HandlerMethodReturnValueHandler
org.springframework.web.method.annotation.ModelMethodProcessor
@Override public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest)
{
    if (returnValue == null) {
        return ;
    } else if (returnValue instanceof Model) {
        mavContainer.addAllAttributes(((Model)returnValue).asMap());
    } else {
        throw new UnsupportedOperationException("Unexpected return type: " + returnType.getParameterType().getName() + " in method: " + returnType.getMethod());
    }
}
org.springframework.web.method.annotation.ModelMethodProcessor
@Override @Nullable public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory)
{
    Assert.state(mavContainer != null, "ModelAndViewContainer is required for model exposure");
    return mavContainer.getModel();
}
org.springframework.web.method.annotation.ModelMethodProcessor
@Override public boolean supportsParameter(MethodParameter parameter)
{
    return Model.class.isAssignableFrom(parameter.getParameterType());
}
org.springframework.web.method.annotation.ModelMethodProcessor
@Override public boolean supportsReturnType(MethodParameter returnType)
{
    return Model.class.isAssignableFrom(returnType.getParameterType());
}
 RequestHeaderMapMethodArgumentResolver
 implements HandlerMethodArgumentResolver
org.springframework.web.method.annotation.RequestHeaderMapMethodArgumentResolver
@Override public boolean supportsParameter(MethodParameter parameter)
{
    return (parameter.hasParameterAnnotation(RequestHeader.class) && Map.class.isAssignableFrom(parameter.getParameterType()));
}
 RequestHeaderMethodArgumentResolver
 extends AbstractNamedValueMethodArgumentResolver
org.springframework.web.method.annotation.RequestHeaderMethodArgumentResolver
public RequestHeaderMethodArgumentResolver RequestHeaderMethodArgumentResolver(@Nullable ConfigurableBeanFactory beanFactory)
{
    super(beanFactory);
}
org.springframework.web.method.annotation.RequestHeaderMethodArgumentResolver
@Override protected NamedValueInfo createNamedValueInfo(MethodParameter parameter)
{
    RequestHeader ann = parameter.getParameterAnnotation(RequestHeader.class);
    Assert.state(ann != null, "No RequestHeader annotation");
    return new RequestHeaderNamedValueInfo(ann);
}
org.springframework.web.method.annotation.RequestHeaderMethodArgumentResolver
@Override protected void handleMissingValue(String name, MethodParameter parameter)
{
    throw new MissingRequestHeaderException(name, parameter);
}
org.springframework.web.method.annotation.RequestHeaderMethodArgumentResolver
@Override @Nullable protected Object resolveName(String name, MethodParameter parameter, NativeWebRequest request)
{
    String[] headerValues = request.getHeaderValues(name);
    if (headerValues != null) {
        return (headerValues.length == 1 ? headerValues[0] : headerValues);
    } else {
        return null;
    }
}
org.springframework.web.method.annotation.RequestHeaderMethodArgumentResolver
@Override public boolean supportsParameter(MethodParameter parameter)
{
    return (parameter.hasParameterAnnotation(RequestHeader.class) && !Map.class.isAssignableFrom(parameter.nestedIfOptional().getNestedParameterType()));
}
 RequestParamMapMethodArgumentResolver
 implements HandlerMethodArgumentResolver
org.springframework.web.method.annotation.RequestParamMapMethodArgumentResolver
@Override public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory)
{
    ResolvableType resolvableType = ResolvableType.forMethodParameter(parameter);
    if (MultiValueMap.class.isAssignableFrom(parameter.getParameterType())) {
        Class<?> valueType = resolvableType.as(MultiValueMap.class).getGeneric(1).resolve();
        if (valueType == MultipartFile.class) {
            MultipartRequest multipartRequest = MultipartResolutionDelegate.resolveMultipartRequest(webRequest);
            return (multipartRequest != null ? multipartRequest.getMultiFileMap() : new LinkedMultiValueMap<>(0));
        } else if (valueType == Part.class) {
            HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
            if (servletRequest != null && MultipartResolutionDelegate.isMultipartRequest(servletRequest)) {
                Collection<Part> parts = servletRequest.getParts();
                LinkedMultiValueMap<String, Part> result = new LinkedMultiValueMap<>(parts.size());
                for (Part part: parts) {
                    result.add(part.getName(), part);
                }
                return result;
            } 
            return new LinkedMultiValueMap<>(0);
        } else {
            Map<String, String[]> parameterMap = webRequest.getParameterMap();
            MultiValueMap<String, String> result = new LinkedMultiValueMap<>(parameterMap.size());
            parameterMap.forEach((key, values) -> {
                for (String value: values) {
                    result.add(key, value);
                }
            });
            return result;
        }
    } else {
        Class<?> valueType = resolvableType.asMap().getGeneric(1).resolve();
        if (valueType == MultipartFile.class) {
            MultipartRequest multipartRequest = MultipartResolutionDelegate.resolveMultipartRequest(webRequest);
            return (multipartRequest != null ? multipartRequest.getFileMap() : new LinkedHashMap<>(0));
        } else if (valueType == Part.class) {
            HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
            if (servletRequest != null && MultipartResolutionDelegate.isMultipartRequest(servletRequest)) {
                Collection<Part> parts = servletRequest.getParts();
                LinkedHashMap<String, Part> result = new LinkedHashMap<>(parts.size());
                for (Part part: parts) {
                    if (!result.containsKey(part.getName())) {
                        result.put(part.getName(), part);
                    } 
                }
                return result;
            } 
            return new LinkedHashMap<>(0);
        } else {
            Map<String, String[]> parameterMap = webRequest.getParameterMap();
            Map<String, String> result = new LinkedHashMap<>(parameterMap.size());
            parameterMap.forEach((key, values) -> {
                if (values.length > 0) {
                    result.put(key, values[0]);
                } 
            });
            return result;
        }
    }
}
org.springframework.web.method.annotation.RequestParamMapMethodArgumentResolver
@Override public boolean supportsParameter(MethodParameter parameter)
{
    RequestParam requestParam = parameter.getParameterAnnotation(RequestParam.class);
    return (requestParam != null && Map.class.isAssignableFrom(parameter.getParameterType()) && !StringUtils.hasText(requestParam.name()));
}
 RequestParamMethodArgumentResolver
 extends AbstractNamedValueMethodArgumentResolver implements UriComponentsContributor
org.springframework.web.method.annotation.RequestParamMethodArgumentResolver
public RequestParamMethodArgumentResolver RequestParamMethodArgumentResolver(boolean useDefaultResolution)
{
    this.useDefaultResolution = useDefaultResolution;
}
org.springframework.web.method.annotation.RequestParamMethodArgumentResolver
public RequestParamMethodArgumentResolver RequestParamMethodArgumentResolver(@Nullable ConfigurableBeanFactory beanFactory, boolean useDefaultResolution)
{
    super(beanFactory);
    this.useDefaultResolution = useDefaultResolution;
}
org.springframework.web.method.annotation.RequestParamMethodArgumentResolver
@Override public void contributeMethodArgument(MethodParameter parameter, @Nullable Object value, UriComponentsBuilder builder, Map<String, Object> uriVariables, ConversionService conversionService)
{
    Class<?> paramType = parameter.getNestedParameterType();
    if (Map.class.isAssignableFrom(paramType) || MultipartFile.class == paramType || Part.class == paramType) {
        return ;
    } 
    RequestParam requestParam = parameter.getParameterAnnotation(RequestParam.class);
    String name = (requestParam != null && StringUtils.hasLength(requestParam.name()) ? requestParam.name() : parameter.getParameterName());
    Assert.state(name != null, "Unresolvable parameter name");
    parameter = parameter.nestedIfOptional();
    if (value instanceof Optional) {
        value = ((Optional<?>)value).orElse(null);
    } 
    if (value == null) {
        if (requestParam != null && (!requestParam.required() || !requestParam.defaultValue().equals(ValueConstants.DEFAULT_NONE))) {
            return ;
        } 
        builder.queryParam(name);
    } else if (value instanceof Collection) {
        for (Object element: (Collection<?>)value) {
            element = formatUriValue(conversionService, TypeDescriptor.nested(parameter, 1), element);
            builder.queryParam(name, element);
        }
    } else {
        builder.queryParam(name, formatUriValue(conversionService, new TypeDescriptor(parameter), value));
    }
}
org.springframework.web.method.annotation.RequestParamMethodArgumentResolver
@Override protected NamedValueInfo createNamedValueInfo(MethodParameter parameter)
{
    RequestParam ann = parameter.getParameterAnnotation(RequestParam.class);
    return (ann != null ? new RequestParamNamedValueInfo(ann) : new RequestParamNamedValueInfo());
}
org.springframework.web.method.annotation.RequestParamMethodArgumentResolver
@Nullable protected String formatUriValue(@Nullable ConversionService cs, @Nullable TypeDescriptor sourceType, @Nullable Object value)
{
    if (value == null) {
        return null;
    } else if (value instanceof String) {
        return (String)value;
    } else if (cs != null) {
        return (String)cs.convert(value, sourceType, STRING_TYPE_DESCRIPTOR);
    } else {
        return value.toString();
    }
}
 SessionAttributesHandler
org.springframework.web.method.annotation.SessionAttributesHandler
public void cleanupAttributes(WebRequest request)
{
    for (String attributeName: this.knownAttributeNames) {
        this.sessionAttributeStore.cleanupAttribute(request, attributeName);
    }
}
org.springframework.web.method.annotation.SessionAttributesHandler
public boolean hasSessionAttributes()
{
    return (!this.attributeNames.isEmpty() || !this.attributeTypes.isEmpty());
}
org.springframework.web.method.annotation.SessionAttributesHandler
public Map<String, Object> retrieveAttributes(WebRequest request)
{
    Map<String, Object> attributes = new HashMap<>();
    for (String name: this.knownAttributeNames) {
        Object value = this.sessionAttributeStore.retrieveAttribute(request, name);
        if (value != null) {
            attributes.put(name, value);
        } 
    }
    return attributes;
}
org.springframework.web.method.annotation.SessionAttributesHandler
public void storeAttributes(WebRequest request, Map<String, ?> attributes)
{
    attributes.forEach((name, value) -> {
        if (value != null && isHandlerSessionAttribute(name, value.getClass())) {
            this.sessionAttributeStore.storeAttribute(request, name, value);
        } 
    });
}
 SessionStatusMethodArgumentResolver
 implements HandlerMethodArgumentResolver
org.springframework.web.method.annotation.SessionStatusMethodArgumentResolver
@Override public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory)
{
    Assert.state(mavContainer != null, "ModelAndViewContainer is required for session status exposure");
    return mavContainer.getSessionStatus();
}
org.springframework.web.method.annotation.SessionStatusMethodArgumentResolver
@Override public boolean supportsParameter(MethodParameter parameter)
{
    return SessionStatus.class == parameter.getParameterType();
}
 AsyncHandlerMethodReturnValueHandler
inherit classes
  • HandlerMethodReturnValueHandler
 CompositeUriComponentsContributor
 implements UriComponentsContributor
org.springframework.web.method.support.CompositeUriComponentsContributor
public CompositeUriComponentsContributor CompositeUriComponentsContributor(UriComponentsContributor... contributors)
{
    Collections.addAll(this.contributors, contributors);
    this.conversionService = new DefaultFormattingConversionService();
}
org.springframework.web.method.support.CompositeUriComponentsContributor
public CompositeUriComponentsContributor CompositeUriComponentsContributor(Collection<?> contributors)
{
    this(contributors, null);
}
org.springframework.web.method.support.CompositeUriComponentsContributor
public CompositeUriComponentsContributor CompositeUriComponentsContributor(@Nullable Collection<?> contributors, @Nullable ConversionService cs)
{
    if (contributors != null) {
        this.contributors.addAll(contributors);
    } 
    this.conversionService = (cs != null ? cs : new DefaultFormattingConversionService());
}
org.springframework.web.method.support.CompositeUriComponentsContributor
@Override public void contributeMethodArgument(MethodParameter parameter, Object value, UriComponentsBuilder builder, Map<String, Object> uriVariables, ConversionService conversionService)
{
    for (Object contributor: this.contributors) {
        if (contributor instanceof UriComponentsContributor) {
            UriComponentsContributor ucc = (UriComponentsContributor)contributor;
            if (ucc.supportsParameter(parameter)) {
                ucc.contributeMethodArgument(parameter, value, builder, uriVariables, conversionService);
                break;
            } 
        } else if (contributor instanceof HandlerMethodArgumentResolver) {
            if (((HandlerMethodArgumentResolver)contributor).supportsParameter(parameter)) {
                break;
            } 
        } 
    }
}
org.springframework.web.method.support.CompositeUriComponentsContributor
public void contributeMethodArgument(MethodParameter parameter, Object value, UriComponentsBuilder builder, Map<String, Object> uriVariables)
{
    this.contributeMethodArgument(parameter, value, builder, uriVariables, this.conversionService);
}
org.springframework.web.method.support.CompositeUriComponentsContributor
public boolean hasContributors()
{
    return this.contributors.isEmpty();
}
org.springframework.web.method.support.CompositeUriComponentsContributor
@Override public boolean supportsParameter(MethodParameter parameter)
{
    for (Object contributor: this.contributors) {
        if (contributor instanceof UriComponentsContributor) {
            if (((UriComponentsContributor)contributor).supportsParameter(parameter)) {
                return true;
            } 
        } else if (contributor instanceof HandlerMethodArgumentResolver) {
            if (((HandlerMethodArgumentResolver)contributor).supportsParameter(parameter)) {
                return false;
            } 
        } 
    }
    return false;
}
 HandlerMethodArgumentResolver
 HandlerMethodArgumentResolverComposite
 implements HandlerMethodArgumentResolver
org.springframework.web.method.support.HandlerMethodArgumentResolverComposite
public HandlerMethodArgumentResolverComposite addResolver(HandlerMethodArgumentResolver resolver)
{
    this.argumentResolvers.add(resolver);
    return this;
}
org.springframework.web.method.support.HandlerMethodArgumentResolverComposite
public HandlerMethodArgumentResolverComposite addResolvers(@Nullable HandlerMethodArgumentResolver... resolvers)
{
    if (resolvers != null) {
        Collections.addAll(this.argumentResolvers, resolvers);
    } 
    return this;
}
org.springframework.web.method.support.HandlerMethodArgumentResolverComposite
public HandlerMethodArgumentResolverComposite addResolvers(@Nullable List<?> resolvers)
{
    if (resolvers != null) {
        this.argumentResolvers.addAll(resolvers);
    } 
    return this;
}
org.springframework.web.method.support.HandlerMethodArgumentResolverComposite
public void clear()
{
    this.argumentResolvers.clear();
}
org.springframework.web.method.support.HandlerMethodArgumentResolverComposite
public List<HandlerMethodArgumentResolver> getResolvers()
{
    return Collections.unmodifiableList(this.argumentResolvers);
}
org.springframework.web.method.support.HandlerMethodArgumentResolverComposite
@Override @Nullable public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory)
{
    HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
    if (resolver == null) {
        throw new IllegalArgumentException("Unsupported parameter type [" + parameter.getParameterType().getName() + "]. supportsParameter should be called first.");
    } 
    return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
}
org.springframework.web.method.support.HandlerMethodArgumentResolverComposite
@Override public boolean supportsParameter(MethodParameter parameter)
{
    return getArgumentResolver(parameter) != null;
}
 HandlerMethodReturnValueHandler
 HandlerMethodReturnValueHandlerComposite
 implements HandlerMethodReturnValueHandler
org.springframework.web.method.support.HandlerMethodReturnValueHandlerComposite
public HandlerMethodReturnValueHandlerComposite addHandler(HandlerMethodReturnValueHandler handler)
{
    this.returnValueHandlers.add(handler);
    return this;
}
org.springframework.web.method.support.HandlerMethodReturnValueHandlerComposite
public HandlerMethodReturnValueHandlerComposite addHandlers(@Nullable List<?> handlers)
{
    if (handlers != null) {
        this.returnValueHandlers.addAll(handlers);
    } 
    return this;
}
org.springframework.web.method.support.HandlerMethodReturnValueHandlerComposite
public List<HandlerMethodReturnValueHandler> getHandlers()
{
    return Collections.unmodifiableList(this.returnValueHandlers);
}
org.springframework.web.method.support.HandlerMethodReturnValueHandlerComposite
@Override public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest)
{
    HandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType);
    if (handler == null) {
        throw new IllegalArgumentException("Unknown return value type: " + returnType.getParameterType().getName());
    } 
    handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
}
org.springframework.web.method.support.HandlerMethodReturnValueHandlerComposite
protected final Log logger
org.springframework.web.method.support.HandlerMethodReturnValueHandlerComposite
@Override public boolean supportsReturnType(MethodParameter returnType)
{
    return getReturnValueHandler(returnType) != null;
}
 InvocableHandlerMethod
 extends HandlerMethod
org.springframework.web.method.support.InvocableHandlerMethod
public InvocableHandlerMethod InvocableHandlerMethod(HandlerMethod handlerMethod)
{
    super(handlerMethod);
}
org.springframework.web.method.support.InvocableHandlerMethod
public InvocableHandlerMethod InvocableHandlerMethod(Object bean, Method method)
{
    super(bean, method);
}
org.springframework.web.method.support.InvocableHandlerMethod
public InvocableHandlerMethod InvocableHandlerMethod(Object bean, String methodName, Class<?>... parameterTypes)
{
    super(bean, methodName, parameterTypes);
}
org.springframework.web.method.support.InvocableHandlerMethod
@Nullable public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, Object... providedArgs)
{
    Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
    if (logger.isTraceEnabled()) {
        logger.trace("Arguments: " + Arrays.toString(args));
    } 
    return doInvoke(args);
}
org.springframework.web.method.support.InvocableHandlerMethod
public void setDataBinderFactory(WebDataBinderFactory dataBinderFactory)
{
    this.dataBinderFactory = dataBinderFactory;
}
org.springframework.web.method.support.InvocableHandlerMethod
public void setHandlerMethodArgumentResolvers(HandlerMethodArgumentResolverComposite argumentResolvers)
{
    this.resolvers = argumentResolvers;
}
org.springframework.web.method.support.InvocableHandlerMethod
public void setParameterNameDiscoverer(ParameterNameDiscoverer parameterNameDiscoverer)
{
    this.parameterNameDiscoverer = parameterNameDiscoverer;
}
 ModelAndViewContainer
org.springframework.web.method.support.ModelAndViewContainer
public ModelAndViewContainer addAllAttributes(@Nullable Map<String, ?> attributes)
{
    getModel().addAllAttributes(attributes);
    return this;
}
org.springframework.web.method.support.ModelAndViewContainer
public ModelAndViewContainer addAttribute(String name, @Nullable Object value)
{
    getModel().addAttribute(name, value);
    return this;
}
org.springframework.web.method.support.ModelAndViewContainer
public ModelAndViewContainer addAttribute(Object value)
{
    getModel().addAttribute(value);
    return this;
}
org.springframework.web.method.support.ModelAndViewContainer
public boolean containsAttribute(String name)
{
    return getModel().containsAttribute(name);
}
org.springframework.web.method.support.ModelAndViewContainer
public ModelMap getDefaultModel()
{
    return this.defaultModel;
}
org.springframework.web.method.support.ModelAndViewContainer
public ModelMap getModel()
{
    if (useDefaultModel()) {
        return this.defaultModel;
    } else {
        if (this.redirectModel == null) {
            this.redirectModel = new ModelMap();
        } 
        return this.redirectModel;
    }
}
org.springframework.web.method.support.ModelAndViewContainer
public SessionStatus getSessionStatus()
{
    return this.sessionStatus;
}
org.springframework.web.method.support.ModelAndViewContainer
@Nullable public HttpStatus getStatus()
{
    return this.status;
}
org.springframework.web.method.support.ModelAndViewContainer
@Nullable public Object getView()
{
    return this.view;
}
org.springframework.web.method.support.ModelAndViewContainer
@Nullable public String getViewName()
{
    return (this.view instanceof String ? (String)this.view : null);
}
org.springframework.web.method.support.ModelAndViewContainer
public boolean isBindingDisabled(String name)
{
    return (this.bindingDisabled.contains(name) || this.noBinding.contains(name));
}
org.springframework.web.method.support.ModelAndViewContainer
public boolean isRequestHandled()
{
    return this.requestHandled;
}
org.springframework.web.method.support.ModelAndViewContainer
public boolean isViewReference()
{
    return (this.view instanceof String);
}
org.springframework.web.method.support.ModelAndViewContainer
public ModelAndViewContainer mergeAttributes(@Nullable Map<String, ?> attributes)
{
    getModel().mergeAttributes(attributes);
    return this;
}
org.springframework.web.method.support.ModelAndViewContainer
public ModelAndViewContainer removeAttributes(@Nullable Map<String, ?> attributes)
{
    if (attributes != null) {
        for (String key: attributes.keySet()) {
            getModel().remove(key);
        }
    } 
    return this;
}
org.springframework.web.method.support.ModelAndViewContainer
public void setBinding(String attributeName, boolean enabled)
{
    if (!enabled) {
        this.noBinding.add(attributeName);
    } else {
        this.noBinding.remove(attributeName);
    }
}
org.springframework.web.method.support.ModelAndViewContainer
public void setBindingDisabled(String attributeName)
{
    this.bindingDisabled.add(attributeName);
}
org.springframework.web.method.support.ModelAndViewContainer
public void setIgnoreDefaultModelOnRedirect(boolean ignoreDefaultModelOnRedirect)
{
    this.ignoreDefaultModelOnRedirect = ignoreDefaultModelOnRedirect;
}
org.springframework.web.method.support.ModelAndViewContainer
public void setRedirectModel(ModelMap redirectModel)
{
    this.redirectModel = redirectModel;
}
org.springframework.web.method.support.ModelAndViewContainer
public void setRedirectModelScenario(boolean redirectModelScenario)
{
    this.redirectModelScenario = redirectModelScenario;
}
org.springframework.web.method.support.ModelAndViewContainer
public void setRequestHandled(boolean requestHandled)
{
    this.requestHandled = requestHandled;
}
org.springframework.web.method.support.ModelAndViewContainer
public void setStatus(@Nullable HttpStatus status)
{
    this.status = status;
}
org.springframework.web.method.support.ModelAndViewContainer
public void setView(@Nullable Object view)
{
    this.view = view;
}
org.springframework.web.method.support.ModelAndViewContainer
public void setViewName(@Nullable String viewName)
{
    this.view = viewName;
}
 UriComponentsContributor
 MaxUploadSizeExceededException
 extends MultipartException
org.springframework.web.multipart.MaxUploadSizeExceededException
public MaxUploadSizeExceededException MaxUploadSizeExceededException(long maxUploadSize)
{
    this(maxUploadSize, null);
}
org.springframework.web.multipart.MaxUploadSizeExceededException
public MaxUploadSizeExceededException MaxUploadSizeExceededException(long maxUploadSize, @Nullable Throwable ex)
{
    super("Maximum upload size " + (maxUploadSize >= 0 ? "of " + maxUploadSize + " bytes " : "") + "exceeded", ex);
    this.maxUploadSize = maxUploadSize;
}
org.springframework.web.multipart.MaxUploadSizeExceededException
public long getMaxUploadSize()
{
    return this.maxUploadSize;
}
 MultipartException
 extends NestedRuntimeException
org.springframework.web.multipart.MultipartException
public MultipartException MultipartException(String msg)
{
    super(msg);
}
org.springframework.web.multipart.MultipartException
public MultipartException MultipartException(String msg, @Nullable Throwable cause)
{
    super(msg, cause);
}
 MultipartFile
inherit classes
  • InputStreamSource
 MultipartFileResource
 extends AbstractResource
org.springframework.web.multipart.MultipartFileResource
public MultipartFileResource MultipartFileResource(MultipartFile multipartFile)
{
    Assert.notNull(multipartFile, "MultipartFile must not be null");
    this.multipartFile = multipartFile;
}
org.springframework.web.multipart.MultipartFileResource
@Override public long contentLength()
{
    return this.multipartFile.getSize();
}
org.springframework.web.multipart.MultipartFileResource
@Override public boolean equals(@Nullable Object other)
{
    return (this == other || (other instanceof MultipartFileResource && ((MultipartFileResource)other).multipartFile.equals(this.multipartFile)));
}
org.springframework.web.multipart.MultipartFileResource
@Override public boolean exists()
{
    return true;
}
org.springframework.web.multipart.MultipartFileResource
@Override public String getDescription()
{
    return "MultipartFile resource [" + this.multipartFile.getName() + "]";
}
org.springframework.web.multipart.MultipartFileResource
@Override public String getFilename()
{
    return this.multipartFile.getOriginalFilename();
}
org.springframework.web.multipart.MultipartFileResource
@Override public InputStream getInputStream()
{
    return this.multipartFile.getInputStream();
}
org.springframework.web.multipart.MultipartFileResource
@Override public int hashCode()
{
    return this.multipartFile.hashCode();
}
org.springframework.web.multipart.MultipartFileResource
@Override public boolean isOpen()
{
    return true;
}
 MultipartHttpServletRequest
inherit classes
  • HttpServletRequest
  • MultipartRequest
 MultipartRequest
 MultipartResolver
 CommonsFileUploadSupport
org.springframework.web.multipart.commons.CommonsFileUploadSupport
public CommonsFileUploadSupport CommonsFileUploadSupport()
{
    this.fileItemFactory = newFileItemFactory();
    this.fileUpload = newFileUpload(getFileItemFactory());
}
 MultipartParsingResult
org.springframework.web.multipart.commons.CommonsFileUploadSupport.MultipartParsingResult
public MultipartParsingResult MultipartParsingResult(MultiValueMap<String, MultipartFile> mpFiles, Map<String, String[]> mpParams, Map<String, String> mpParamContentTypes)
{
    this.multipartFiles = mpFiles;
    this.multipartParameters = mpParams;
    this.multipartParameterContentTypes = mpParamContentTypes;
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport.MultipartParsingResult
public MultiValueMap<String, MultipartFile> getMultipartFiles()
{
    return this.multipartFiles;
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport.MultipartParsingResult
public Map<String, String> getMultipartParameterContentTypes()
{
    return this.multipartParameterContentTypes;
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport.MultipartParsingResult
public Map<String, String[]> getMultipartParameters()
{
    return this.multipartParameters;
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport
protected CommonsMultipartFile createMultipartFile(FileItem fileItem)
{
    CommonsMultipartFile multipartFile = new CommonsMultipartFile(fileItem);
    multipartFile.setPreserveFilename(this.preserveFilename);
    return multipartFile;
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport
protected String getDefaultEncoding()
{
    String encoding = getFileUpload().getHeaderEncoding();
    if (encoding == null) {
        encoding = WebUtils.DEFAULT_CHARACTER_ENCODING;
    } 
    return encoding;
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport
public DiskFileItemFactory getFileItemFactory()
{
    return this.fileItemFactory;
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport
public FileUpload getFileUpload()
{
    return this.fileUpload;
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport
protected boolean isUploadTempDirSpecified()
{
    return this.uploadTempDirSpecified;
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport
protected final Log logger
org.springframework.web.multipart.commons.CommonsFileUploadSupport
protected DiskFileItemFactory newFileItemFactory()
{
    return new DiskFileItemFactory();
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport
protected abstract FileUpload newFileUpload(FileItemFactory fileItemFactory)
org.springframework.web.multipart.commons.CommonsFileUploadSupport
protected MultipartParsingResult parseFileItems(List<FileItem> fileItems, String encoding)
{
    MultiValueMap<String, MultipartFile> multipartFiles = new LinkedMultiValueMap<>();
    Map<String, String[]> multipartParameters = new HashMap<>();
    Map<String, String> multipartParameterContentTypes = new HashMap<>();
    for (FileItem fileItem: fileItems) {
        if (fileItem.isFormField()) {
            String value;
            String partEncoding = determineEncoding(fileItem.getContentType(), encoding);
            try {
                value = fileItem.getString(partEncoding);
            } catch (UnsupportedEncodingException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Could not decode multipart item '" + fileItem.getFieldName() + "' with encoding '" + partEncoding + "': using platform default");
                } 
                value = fileItem.getString();
            }
            String[] curParam = multipartParameters.get(fileItem.getFieldName());
            if (curParam == null) {
                multipartParameters.put(fileItem.getFieldName(), new String[]{value});
            } else {
                String[] newParam = StringUtils.addStringToArray(curParam, value);
                multipartParameters.put(fileItem.getFieldName(), newParam);
            }
            multipartParameterContentTypes.put(fileItem.getFieldName(), fileItem.getContentType());
        } else {
            CommonsMultipartFile file = createMultipartFile(fileItem);
            multipartFiles.add(file.getName(), file);
            LogFormatUtils.traceDebug(logger, traceOn -> "Part '" + file.getName() + "', size " + file.getSize() + " bytes, filename='" + file.getOriginalFilename() + "'" + (traceOn ? ", storage=" + file.getStorageDescription() : ""));
        }
    }
    return new MultipartParsingResult(multipartFiles, multipartParameters, multipartParameterContentTypes);
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport
public void setDefaultEncoding(String defaultEncoding)
{
    this.fileUpload.setHeaderEncoding(defaultEncoding);
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport
public void setMaxInMemorySize(int maxInMemorySize)
{
    this.fileItemFactory.setSizeThreshold(maxInMemorySize);
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport
public void setMaxUploadSize(long maxUploadSize)
{
    this.fileUpload.setSizeMax(maxUploadSize);
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport
public void setMaxUploadSizePerFile(long maxUploadSizePerFile)
{
    this.fileUpload.setFileSizeMax(maxUploadSizePerFile);
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport
public void setPreserveFilename(boolean preserveFilename)
{
    this.preserveFilename = preserveFilename;
}
org.springframework.web.multipart.commons.CommonsFileUploadSupport
public void setUploadTempDir(Resource uploadTempDir)
{
    if (!uploadTempDir.exists() && !uploadTempDir.getFile().mkdirs()) {
        throw new IllegalArgumentException("Given uploadTempDir [" + uploadTempDir + "] could not be created");
    } 
    this.fileItemFactory.setRepository(uploadTempDir.getFile());
    this.uploadTempDirSpecified = true;
}
 CommonsMultipartFile
 implements MultipartFile, Serializable
org.springframework.web.multipart.commons.CommonsMultipartFile
public CommonsMultipartFile CommonsMultipartFile(FileItem fileItem)
{
    this.fileItem = fileItem;
    this.size = this.fileItem.getSize();
}
org.springframework.web.multipart.commons.CommonsMultipartFile
@Override public byte[] getBytes()
{
    if (!isAvailable()) {
        throw new IllegalStateException("File has been moved - cannot be read again");
    } 
    byte[] bytes = this.fileItem.get();
    return (bytes != null ? bytes : new byte[0]);
}
org.springframework.web.multipart.commons.CommonsMultipartFile
@Override public String getContentType()
{
    return this.fileItem.getContentType();
}
org.springframework.web.multipart.commons.CommonsMultipartFile
public final FileItem getFileItem()
{
    return this.fileItem;
}
org.springframework.web.multipart.commons.CommonsMultipartFile
@Override public InputStream getInputStream()
{
    if (!isAvailable()) {
        throw new IllegalStateException("File has been moved - cannot be read again");
    } 
    InputStream inputStream = this.fileItem.getInputStream();
    return (inputStream != null ? inputStream : StreamUtils.emptyInput());
}
org.springframework.web.multipart.commons.CommonsMultipartFile
@Override public String getName()
{
    return this.fileItem.getFieldName();
}
org.springframework.web.multipart.commons.CommonsMultipartFile
@Override public String getOriginalFilename()
{
    String filename = this.fileItem.getName();
    if (filename == null) {
        return "";
    } 
    if (this.preserveFilename) {
        return filename;
    } 
    int unixSep = filename.lastIndexOf('/');
    int winSep = filename.lastIndexOf('\\');
    int pos = Math.max(winSep, unixSep);
    if (pos != -1) {
        return filename.substring(pos + 1);
    } else {
        return filename;
    }
}
org.springframework.web.multipart.commons.CommonsMultipartFile
@Override public long getSize()
{
    return this.size;
}
org.springframework.web.multipart.commons.CommonsMultipartFile
public String getStorageDescription()
{
    if (this.fileItem.isInMemory()) {
        return "in memory";
    } else if (this.fileItem instanceof DiskFileItem) {
        return "at [" + ((DiskFileItem)this.fileItem).getStoreLocation().getAbsolutePath() + "]";
    } else {
        return "on disk";
    }
}
org.springframework.web.multipart.commons.CommonsMultipartFile
protected boolean isAvailable()
{
    if (this.fileItem.isInMemory()) {
        return true;
    } 
    if (this.fileItem instanceof DiskFileItem) {
        return ((DiskFileItem)this.fileItem).getStoreLocation().exists();
    } 
    return (this.fileItem.getSize() == this.size);
}
org.springframework.web.multipart.commons.CommonsMultipartFile
@Override public boolean isEmpty()
{
    return (this.size == 0);
}
org.springframework.web.multipart.commons.CommonsMultipartFile
protected static final Log logger
org.springframework.web.multipart.commons.CommonsMultipartFile
public void setPreserveFilename(boolean preserveFilename)
{
    this.preserveFilename = preserveFilename;
}
org.springframework.web.multipart.commons.CommonsMultipartFile
@Override public void transferTo(File dest)
{
    if (!isAvailable()) {
        throw new IllegalStateException("File has already been moved - cannot be transferred again");
    } 
    if (dest.exists() && !dest.delete()) {
        throw new IOException("Destination file [" + dest.getAbsolutePath() + "] already exists and could not be deleted");
    } 
    try {
        this.fileItem.write(dest);
        LogFormatUtils.traceDebug(logger, traceOn -> {
            String action = "transferred";
            if (!this.fileItem.isInMemory()) {
                action = (isAvailable() ? "copied" : "moved");
            } 
            return "Part '" + getName() + "',  filename '" + getOriginalFilename() + "'" + (traceOn ? ", stored " + getStorageDescription() : "") + ": " + action + " to [" + dest.getAbsolutePath() + "]";
        });
    } catch (FileUploadException ex) {
        throw new IllegalStateException(ex.getMessage(), ex);
    } catch (IllegalStateException | IOException ex) {
        throw ex;
    } catch (Exception ex) {
        throw new IOException("File transfer failed", ex);
    }
}
org.springframework.web.multipart.commons.CommonsMultipartFile
@Override public void transferTo(Path dest)
{
    if (!isAvailable()) {
        throw new IllegalStateException("File has already been moved - cannot be transferred again");
    } 
    FileCopyUtils.copy(this.fileItem.getInputStream(), Files.newOutputStream(dest));
}
 CommonsMultipartResolver
 extends CommonsFileUploadSupport implements MultipartResolver, ServletContextAware
org.springframework.web.multipart.commons.CommonsMultipartResolver
public CommonsMultipartResolver CommonsMultipartResolver()
{
    super();
}
org.springframework.web.multipart.commons.CommonsMultipartResolver
public CommonsMultipartResolver CommonsMultipartResolver(ServletContext servletContext)
{
    this();
    setServletContext(servletContext);
}
org.springframework.web.multipart.commons.CommonsMultipartResolver
protected String determineEncoding(HttpServletRequest request)
{
    String encoding = request.getCharacterEncoding();
    if (encoding == null) {
        encoding = getDefaultEncoding();
    } 
    return encoding;
}
org.springframework.web.multipart.commons.CommonsMultipartResolver
@Override public boolean isMultipart(HttpServletRequest request)
{
    return ServletFileUpload.isMultipartContent(request);
}
org.springframework.web.multipart.commons.CommonsMultipartResolver
@Override protected FileUpload newFileUpload(FileItemFactory fileItemFactory)
{
    return new ServletFileUpload(fileItemFactory);
}
org.springframework.web.multipart.commons.CommonsMultipartResolver
public void setResolveLazily(boolean resolveLazily)
{
    this.resolveLazily = resolveLazily;
}
org.springframework.web.multipart.commons.CommonsMultipartResolver
@Override public void setServletContext(ServletContext servletContext)
{
    if (!isUploadTempDirSpecified()) {
        getFileItemFactory().setRepository(WebUtils.getTempDir(servletContext));
    } 
}
 AbstractMultipartHttpServletRequest
 extends HttpServletRequestWrapper implements MultipartHttpServletRequest
org.springframework.web.multipart.support.AbstractMultipartHttpServletRequest
protected AbstractMultipartHttpServletRequest AbstractMultipartHttpServletRequest(HttpServletRequest request)
{
    super(request);
}
org.springframework.web.multipart.support.AbstractMultipartHttpServletRequest
@Override public MultipartFile getFile(String name)
{
    return getMultipartFiles().getFirst(name);
}
org.springframework.web.multipart.support.AbstractMultipartHttpServletRequest
@Override public Map<String, MultipartFile> getFileMap()
{
    return getMultipartFiles().toSingleValueMap();
}
org.springframework.web.multipart.support.AbstractMultipartHttpServletRequest
@Override public Iterator<String> getFileNames()
{
    return getMultipartFiles().keySet().iterator();
}
org.springframework.web.multipart.support.AbstractMultipartHttpServletRequest
@Override public List<MultipartFile> getFiles(String name)
{
    List<MultipartFile> multipartFiles = getMultipartFiles().get(name);
    if (multipartFiles != null) {
        return multipartFiles;
    } else {
        return Collections.emptyList();
    }
}
org.springframework.web.multipart.support.AbstractMultipartHttpServletRequest
@Override public MultiValueMap<String, MultipartFile> getMultiFileMap()
{
    return getMultipartFiles();
}
org.springframework.web.multipart.support.AbstractMultipartHttpServletRequest
protected MultiValueMap<String, MultipartFile> getMultipartFiles()
{
    if (this.multipartFiles == null) {
        initializeMultipart();
    } 
    return this.multipartFiles;
}
org.springframework.web.multipart.support.AbstractMultipartHttpServletRequest
@Override public HttpServletRequest getRequest()
{
    return (HttpServletRequest)super.getRequest();
}
org.springframework.web.multipart.support.AbstractMultipartHttpServletRequest
@Override public HttpMethod getRequestMethod()
{
    return HttpMethod.resolve(getRequest().getMethod());
}
org.springframework.web.multipart.support.AbstractMultipartHttpServletRequest
protected void initializeMultipart()
{
    throw new IllegalStateException("Multipart request not initialized");
}
org.springframework.web.multipart.support.AbstractMultipartHttpServletRequest
public boolean isResolved()
{
    return (this.multipartFiles != null);
}
org.springframework.web.multipart.support.AbstractMultipartHttpServletRequest
protected final void setMultipartFiles(MultiValueMap<String, MultipartFile> multipartFiles)
{
    this.multipartFiles = new LinkedMultiValueMap<>(Collections.unmodifiableMap(multipartFiles));
}
 ByteArrayMultipartFileEditor
 extends ByteArrayPropertyEditor
org.springframework.web.multipart.support.ByteArrayMultipartFileEditor
@Override public String getAsText()
{
    byte[] value = (byte[])getValue();
    return (value != null ? new String(value) : "");
}
 DefaultMultipartHttpServletRequest
 extends AbstractMultipartHttpServletRequest
org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest
public DefaultMultipartHttpServletRequest DefaultMultipartHttpServletRequest(HttpServletRequest request, MultiValueMap<String, MultipartFile> mpFiles, Map<String, String[]> mpParams, Map<String, String> mpParamContentTypes)
{
    super(request);
    setMultipartFiles(mpFiles);
    setMultipartParameters(mpParams);
    setMultipartParameterContentTypes(mpParamContentTypes);
}
org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest
public DefaultMultipartHttpServletRequest DefaultMultipartHttpServletRequest(HttpServletRequest request)
{
    super(request);
}
org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest
@Override public String getMultipartContentType(String paramOrFileName)
{
    MultipartFile file = getFile(paramOrFileName);
    if (file != null) {
        return file.getContentType();
    } else {
        return getMultipartParameterContentTypes().get(paramOrFileName);
    }
}
org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest
@Override public HttpHeaders getMultipartHeaders(String paramOrFileName)
{
    String contentType = getMultipartContentType(paramOrFileName);
    if (contentType != null) {
        HttpHeaders headers = new HttpHeaders();
        headers.add(CONTENT_TYPE, contentType);
        return headers;
    } else {
        return null;
    }
}
org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest
protected Map<String, String> getMultipartParameterContentTypes()
{
    if (this.multipartParameterContentTypes == null) {
        initializeMultipart();
    } 
    return this.multipartParameterContentTypes;
}
org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest
protected Map<String, String[]> getMultipartParameters()
{
    if (this.multipartParameters == null) {
        initializeMultipart();
    } 
    return this.multipartParameters;
}
org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest
@Override @Nullable public String getParameter(String name)
{
    String[] values = getMultipartParameters().get(name);
    if (values != null) {
        return (values.length > 0 ? values[0] : null);
    } 
    return super.getParameter(name);
}
org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest
@Override public Map<String, String[]> getParameterMap()
{
    Map<String, String[]> result = new LinkedHashMap<>();
    Enumeration<String> names = getParameterNames();
    while (names.hasMoreElements()) {
        String name = names.nextElement();
        result.put(name, getParameterValues(name));
    }
    return result;
}
org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest
@Override public Enumeration<String> getParameterNames()
{
    Map<String, String[]> multipartParameters = getMultipartParameters();
    if (multipartParameters.isEmpty()) {
        return super.getParameterNames();
    } 
    Set<String> paramNames = new LinkedHashSet<>();
    paramNames.addAll(Collections.list(super.getParameterNames()));
    paramNames.addAll(multipartParameters.keySet());
    return Collections.enumeration(paramNames);
}
org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest
protected final void setMultipartParameterContentTypes(Map<String, String> multipartParameterContentTypes)
{
    this.multipartParameterContentTypes = multipartParameterContentTypes;
}
org.springframework.web.multipart.support.DefaultMultipartHttpServletRequest
protected final void setMultipartParameters(Map<String, String[]> multipartParameters)
{
    this.multipartParameters = multipartParameters;
}
 MissingServletRequestPartException
 extends ServletException
org.springframework.web.multipart.support.MissingServletRequestPartException
public MissingServletRequestPartException MissingServletRequestPartException(String partName)
{
    super("Required request part '" + partName + "' is not present");
    this.partName = partName;
}
org.springframework.web.multipart.support.MissingServletRequestPartException
public String getRequestPartName()
{
    return this.partName;
}
 MultipartFilter
 extends OncePerRequestFilter
org.springframework.web.multipart.support.MultipartFilter
public static final String DEFAULT_MULTIPART_RESOLVER_BEAN_NAME
org.springframework.web.multipart.support.MultipartFilter
protected String getMultipartResolverBeanName()
{
    return this.multipartResolverBeanName;
}
org.springframework.web.multipart.support.MultipartFilter
protected MultipartResolver lookupMultipartResolver(HttpServletRequest request)
{
    return lookupMultipartResolver();
}
org.springframework.web.multipart.support.MultipartFilter
public void setMultipartResolverBeanName(String multipartResolverBeanName)
{
    this.multipartResolverBeanName = multipartResolverBeanName;
}
 MultipartResolutionDelegate
org.springframework.web.multipart.support.MultipartResolutionDelegate
public static final Object UNRESOLVABLE
org.springframework.web.multipart.support.MultipartResolutionDelegate
public static boolean isMultipartRequest(HttpServletRequest request)
{
    return (WebUtils.getNativeRequest(request, MultipartHttpServletRequest.class) != null || isMultipartContent(request));
}
org.springframework.web.multipart.support.MultipartResolutionDelegate
@Nullable public static Object resolveMultipartArgument(String name, MethodParameter parameter, HttpServletRequest request)
{
    MultipartHttpServletRequest multipartRequest = WebUtils.getNativeRequest(request, MultipartHttpServletRequest.class);
    boolean isMultipart = (multipartRequest != null || isMultipartContent(request));
    if (MultipartFile.class == parameter.getNestedParameterType()) {
        if (multipartRequest == null && isMultipart) {
            multipartRequest = new StandardMultipartHttpServletRequest(request);
        } 
        return (multipartRequest != null ? multipartRequest.getFile(name) : null);
    } else if (isMultipartFileCollection(parameter)) {
        if (multipartRequest == null && isMultipart) {
            multipartRequest = new StandardMultipartHttpServletRequest(request);
        } 
        return (multipartRequest != null ? multipartRequest.getFiles(name) : null);
    } else if (isMultipartFileArray(parameter)) {
        if (multipartRequest == null && isMultipart) {
            multipartRequest = new StandardMultipartHttpServletRequest(request);
        } 
        if (multipartRequest != null) {
            List<MultipartFile> multipartFiles = multipartRequest.getFiles(name);
            return multipartFiles.toArray(new MultipartFile[0]);
        } else {
            return null;
        }
    } else if (Part.class == parameter.getNestedParameterType()) {
        return (isMultipart ? request.getPart(name) : null);
    } else if (isPartCollection(parameter)) {
        return (isMultipart ? resolvePartList(request, name) : null);
    } else if (isPartArray(parameter)) {
        return (isMultipart ? resolvePartList(request, name).toArray(new Part[0]) : null);
    } else {
        return UNRESOLVABLE;
    }
}
org.springframework.web.multipart.support.MultipartResolutionDelegate
@Nullable public static MultipartRequest resolveMultipartRequest(NativeWebRequest webRequest)
{
    MultipartRequest multipartRequest = webRequest.getNativeRequest(MultipartRequest.class);
    if (multipartRequest != null) {
        return multipartRequest;
    } 
    HttpServletRequest servletRequest = webRequest.getNativeRequest(HttpServletRequest.class);
    if (servletRequest != null && isMultipartContent(servletRequest)) {
        return new StandardMultipartHttpServletRequest(servletRequest);
    } 
    return null;
}
 RequestPartServletServerHttpRequest
 extends ServletServerHttpRequest
org.springframework.web.multipart.support.RequestPartServletServerHttpRequest
public RequestPartServletServerHttpRequest RequestPartServletServerHttpRequest(HttpServletRequest request, String partName)
{
    super(request);
    this.multipartRequest = MultipartResolutionDelegate.asMultipartHttpServletRequest(request);
    this.partName = partName;
    HttpHeaders headers = this.multipartRequest.getMultipartHeaders(this.partName);
    if (headers == null) {
        throw new MissingServletRequestPartException(partName);
    } 
    this.headers = headers;
}
org.springframework.web.multipart.support.RequestPartServletServerHttpRequest
@Override public HttpHeaders getHeaders()
{
    return this.headers;
}
 StandardMultipartHttpServletRequest
 extends AbstractMultipartHttpServletRequest
org.springframework.web.multipart.support.StandardMultipartHttpServletRequest
public StandardMultipartHttpServletRequest StandardMultipartHttpServletRequest(HttpServletRequest request)
{
    this(request, false);
}
org.springframework.web.multipart.support.StandardMultipartHttpServletRequest
public StandardMultipartHttpServletRequest StandardMultipartHttpServletRequest(HttpServletRequest request, boolean lazyParsing)
{
    super(request);
    if (!lazyParsing) {
        parseRequest(request);
    } 
}
org.springframework.web.multipart.support.StandardMultipartHttpServletRequest
@Override public String getMultipartContentType(String paramOrFileName)
{
    try {
        Part part = getPart(paramOrFileName);
        return (part != null ? part.getContentType() : null);
    } catch (Throwable ex) {
        throw new MultipartException("Could not access multipart servlet request", ex);
    }
}
org.springframework.web.multipart.support.StandardMultipartHttpServletRequest
@Override public Map<String, String[]> getParameterMap()
{
    if (this.multipartParameterNames == null) {
        initializeMultipart();
    } 
    if (this.multipartParameterNames.isEmpty()) {
        return super.getParameterMap();
    } 
    Map<String, String[]> paramMap = new LinkedHashMap<>(super.getParameterMap());
    for (String paramName: this.multipartParameterNames) {
        if (!paramMap.containsKey(paramName)) {
            paramMap.put(paramName, getParameterValues(paramName));
        } 
    }
    return paramMap;
}
org.springframework.web.multipart.support.StandardMultipartHttpServletRequest
@Override public Enumeration<String> getParameterNames()
{
    if (this.multipartParameterNames == null) {
        initializeMultipart();
    } 
    if (this.multipartParameterNames.isEmpty()) {
        return super.getParameterNames();
    } 
    Set<String> paramNames = new LinkedHashSet<>();
    Enumeration<String> paramEnum = super.getParameterNames();
    while (paramEnum.hasMoreElements()) {
        paramNames.add(paramEnum.nextElement());
    }
    paramNames.addAll(this.multipartParameterNames);
    return Collections.enumeration(paramNames);
}
org.springframework.web.multipart.support.StandardMultipartHttpServletRequest
protected void handleParseFailure(Throwable ex)
{
    String msg = ex.getMessage();
    if (msg != null && msg.contains("size") && msg.contains("exceed")) {
        throw new MaxUploadSizeExceededException(-1, ex);
    } 
    throw new MultipartException("Failed to parse multipart servlet request", ex);
}
org.springframework.web.multipart.support.StandardMultipartHttpServletRequest
@Override protected void initializeMultipart()
{
    parseRequest(getRequest());
}
 StandardServletMultipartResolver
 implements MultipartResolver
org.springframework.web.multipart.support.StandardServletMultipartResolver
@Override public boolean isMultipart(HttpServletRequest request)
{
    return StringUtils.startsWithIgnoreCase(request.getContentType(), "multipart/");
}
org.springframework.web.multipart.support.StandardServletMultipartResolver
@Override public MultipartHttpServletRequest resolveMultipart(HttpServletRequest request)
{
    return new StandardMultipartHttpServletRequest(request, this.resolveLazily);
}
org.springframework.web.multipart.support.StandardServletMultipartResolver
public void setResolveLazily(boolean resolveLazily)
{
    this.resolveLazily = resolveLazily;
}
 StringMultipartFileEditor
 extends PropertyEditorSupport
org.springframework.web.multipart.support.StringMultipartFileEditor
public StringMultipartFileEditor StringMultipartFileEditor()
{
    this.charsetName = null;
}
org.springframework.web.multipart.support.StringMultipartFileEditor
public StringMultipartFileEditor StringMultipartFileEditor(String charsetName)
{
    this.charsetName = charsetName;
}
org.springframework.web.multipart.support.StringMultipartFileEditor
@Override public void setAsText(String text)
{
    setValue(text);
}
 DefaultServerWebExchangeBuilder
 implements ServerWebExchange.Builder
org.springframework.web.server.DefaultServerWebExchangeBuilder
@Override public ServerWebExchange build()
{
    return new MutativeDecorator(this.delegate, this.request, this.response, this.principalMono);
}
org.springframework.web.server.DefaultServerWebExchangeBuilder
@Override public ServerWebExchange.Builder principal(Mono<Principal> principalMono)
{
    this.principalMono = principalMono;
    return this;
}
org.springframework.web.server.DefaultServerWebExchangeBuilder
@Override public ServerWebExchange.Builder request(Consumer<ServerHttpRequest.Builder> consumer)
{
    ServerHttpRequest.Builder builder = this.delegate.getRequest().mutate();
    consumer.accept(builder);
    return request(builder.build());
}
org.springframework.web.server.DefaultServerWebExchangeBuilder
@Override public ServerWebExchange.Builder request(ServerHttpRequest request)
{
    this.request = request;
    return this;
}
org.springframework.web.server.DefaultServerWebExchangeBuilder
@Override public ServerWebExchange.Builder response(ServerHttpResponse response)
{
    this.response = response;
    return this;
}
 MediaTypeNotSupportedStatusException
 extends ResponseStatusException
org.springframework.web.server.MediaTypeNotSupportedStatusException
public MediaTypeNotSupportedStatusException MediaTypeNotSupportedStatusException(String reason)
{
    super(HttpStatus.UNSUPPORTED_MEDIA_TYPE, reason);
    this.supportedMediaTypes = Collections.emptyList();
}
org.springframework.web.server.MediaTypeNotSupportedStatusException
public MediaTypeNotSupportedStatusException MediaTypeNotSupportedStatusException(List<MediaType> supportedMediaTypes)
{
    super(HttpStatus.UNSUPPORTED_MEDIA_TYPE, "Unsupported media type", null);
    this.supportedMediaTypes = Collections.unmodifiableList(supportedMediaTypes);
}
org.springframework.web.server.MediaTypeNotSupportedStatusException
public List<MediaType> getSupportedMediaTypes()
{
    return this.supportedMediaTypes;
}
 MethodNotAllowedException
 extends ResponseStatusException
org.springframework.web.server.MethodNotAllowedException
public MethodNotAllowedException MethodNotAllowedException(HttpMethod method, Collection<HttpMethod> supportedMethods)
{
    this(method.name(), supportedMethods);
}
org.springframework.web.server.MethodNotAllowedException
public MethodNotAllowedException MethodNotAllowedException(String method, @Nullable Collection<HttpMethod> supportedMethods)
{
    super(HttpStatus.METHOD_NOT_ALLOWED, "Request method '" + method + "' not supported");
    Assert.notNull(method, "'method' is required");
    if (supportedMethods == null) {
        supportedMethods = Collections.emptySet();
    } 
    this.method = method;
    this.supportedMethods = Collections.unmodifiableSet(new HashSet<>(supportedMethods));
}
org.springframework.web.server.MethodNotAllowedException
public String getHttpMethod()
{
    return this.method;
}
org.springframework.web.server.MethodNotAllowedException
public Set<HttpMethod> getSupportedMethods()
{
    return this.supportedMethods;
}
 NotAcceptableStatusException
 extends ResponseStatusException
org.springframework.web.server.NotAcceptableStatusException
public NotAcceptableStatusException NotAcceptableStatusException(String reason)
{
    super(HttpStatus.NOT_ACCEPTABLE, reason);
    this.supportedMediaTypes = Collections.emptyList();
}
org.springframework.web.server.NotAcceptableStatusException
public NotAcceptableStatusException NotAcceptableStatusException(List<MediaType> supportedMediaTypes)
{
    super(HttpStatus.NOT_ACCEPTABLE, "Could not find acceptable representation");
    this.supportedMediaTypes = Collections.unmodifiableList(supportedMediaTypes);
}
org.springframework.web.server.NotAcceptableStatusException
public List<MediaType> getSupportedMediaTypes()
{
    return this.supportedMediaTypes;
}
 ResponseStatusException
 extends NestedRuntimeException
org.springframework.web.server.ResponseStatusException
public ResponseStatusException ResponseStatusException(HttpStatus status)
{
    this(status, null, null);
}
org.springframework.web.server.ResponseStatusException
public ResponseStatusException ResponseStatusException(HttpStatus status, @Nullable String reason)
{
    this(status, reason, null);
}
org.springframework.web.server.ResponseStatusException
public ResponseStatusException ResponseStatusException(HttpStatus status, @Nullable String reason, @Nullable Throwable cause)
{
    super(null, cause);
    Assert.notNull(status, "HttpStatus is required");
    this.status = status;
    this.reason = reason;
}
org.springframework.web.server.ResponseStatusException
@Nullable public String getReason()
{
    return this.reason;
}
org.springframework.web.server.ResponseStatusException
public HttpStatus getStatus()
{
    return this.status;
}
 ServerErrorException
 extends ResponseStatusException
org.springframework.web.server.ServerErrorException
public ServerErrorException ServerErrorException(String reason, @Nullable Throwable cause)
{
    super(HttpStatus.INTERNAL_SERVER_ERROR, reason, cause);
    this.handlerMethod = null;
    this.parameter = null;
}
org.springframework.web.server.ServerErrorException
public ServerErrorException ServerErrorException(String reason, Method handlerMethod, @Nullable Throwable cause)
{
    super(HttpStatus.INTERNAL_SERVER_ERROR, reason, cause);
    this.handlerMethod = handlerMethod;
    this.parameter = null;
}
org.springframework.web.server.ServerErrorException
public ServerErrorException ServerErrorException(String reason, MethodParameter parameter, @Nullable Throwable cause)
{
    super(HttpStatus.INTERNAL_SERVER_ERROR, reason, cause);
    this.handlerMethod = parameter.getMethod();
    this.parameter = parameter;
}
org.springframework.web.server.ServerErrorException
@Deprecated public ServerErrorException ServerErrorException(String reason, MethodParameter parameter)
{
    this(reason, parameter, null);
}
org.springframework.web.server.ServerErrorException
@Deprecated public ServerErrorException ServerErrorException(String reason)
{
    super(HttpStatus.INTERNAL_SERVER_ERROR, reason, null);
    this.handlerMethod = null;
    this.parameter = null;
}
org.springframework.web.server.ServerErrorException
@Nullable public Method getHandlerMethod()
{
    return this.handlerMethod;
}
org.springframework.web.server.ServerErrorException
@Nullable public MethodParameter getMethodParameter()
{
    return this.parameter;
}
 ServerWebExchange
 ServerWebExchangeDecorator
 implements ServerWebExchange
org.springframework.web.server.ServerWebExchangeDecorator
protected ServerWebExchangeDecorator ServerWebExchangeDecorator(ServerWebExchange delegate)
{
    Assert.notNull(delegate, "ServerWebExchange 'delegate' is required.");
    this.delegate = delegate;
}
org.springframework.web.server.ServerWebExchangeDecorator
@Override public void addUrlTransformer(Function<String, String> transformer)
{
    getDelegate().addUrlTransformer(transformer);
}
org.springframework.web.server.ServerWebExchangeDecorator
@Override public boolean checkNotModified(Instant lastModified)
{
    return getDelegate().checkNotModified(lastModified);
}
org.springframework.web.server.ServerWebExchangeDecorator
@Override public boolean checkNotModified(String etag)
{
    return getDelegate().checkNotModified(etag);
}
org.springframework.web.server.ServerWebExchangeDecorator
@Override public boolean checkNotModified(@Nullable String etag, Instant lastModified)
{
    return getDelegate().checkNotModified(etag, lastModified);
}
org.springframework.web.server.ServerWebExchangeDecorator
@Override public ApplicationContext getApplicationContext()
{
    return getDelegate().getApplicationContext();
}
org.springframework.web.server.ServerWebExchangeDecorator
@Override public Map<String, Object> getAttributes()
{
    return getDelegate().getAttributes();
}
org.springframework.web.server.ServerWebExchangeDecorator
public ServerWebExchange getDelegate()
{
    return this.delegate;
}
org.springframework.web.server.ServerWebExchangeDecorator
@Override public Mono<MultiValueMap<String, String>> getFormData()
{
    return getDelegate().getFormData();
}
org.springframework.web.server.ServerWebExchangeDecorator
@Override public LocaleContext getLocaleContext()
{
    return getDelegate().getLocaleContext();
}
org.springframework.web.server.ServerWebExchangeDecorator
@Override public String getLogPrefix()
{
    return getDelegate().getLogPrefix();
}
org.springframework.web.server.ServerWebExchangeDecorator
@Override public Mono<MultiValueMap<String, Part>> getMultipartData()
{
    return getDelegate().getMultipartData();
}
org.springframework.web.server.ServerWebExchangeDecorator
<T>@Override public Mono<T> getPrincipal()
{
    return getDelegate().getPrincipal();
}
org.springframework.web.server.ServerWebExchangeDecorator
@Override public ServerHttpRequest getRequest()
{
    return getDelegate().getRequest();
}
org.springframework.web.server.ServerWebExchangeDecorator
@Override public ServerHttpResponse getResponse()
{
    return getDelegate().getResponse();
}
org.springframework.web.server.ServerWebExchangeDecorator
@Override public Mono<WebSession> getSession()
{
    return getDelegate().getSession();
}
org.springframework.web.server.ServerWebExchangeDecorator
@Override public boolean isNotModified()
{
    return getDelegate().isNotModified();
}
org.springframework.web.server.ServerWebExchangeDecorator
@Override public String toString()
{
    return getClass().getSimpleName() + " [delegate=" + getDelegate() + "]";
}
org.springframework.web.server.ServerWebExchangeDecorator
@Override public String transformUrl(String url)
{
    return getDelegate().transformUrl(url);
}
 ServerWebInputException
 extends ResponseStatusException
org.springframework.web.server.ServerWebInputException
public ServerWebInputException ServerWebInputException(String reason)
{
    this(reason, null, null);
}
org.springframework.web.server.ServerWebInputException
public ServerWebInputException ServerWebInputException(String reason, @Nullable MethodParameter parameter)
{
    this(reason, parameter, null);
}
org.springframework.web.server.ServerWebInputException
public ServerWebInputException ServerWebInputException(String reason, @Nullable MethodParameter parameter, @Nullable Throwable cause)
{
    super(HttpStatus.BAD_REQUEST, reason, cause);
    this.parameter = parameter;
}
org.springframework.web.server.ServerWebInputException
@Nullable public MethodParameter getMethodParameter()
{
    return this.parameter;
}
 UnsupportedMediaTypeStatusException
 extends ResponseStatusException
org.springframework.web.server.UnsupportedMediaTypeStatusException
public UnsupportedMediaTypeStatusException UnsupportedMediaTypeStatusException(@Nullable String reason)
{
    super(HttpStatus.UNSUPPORTED_MEDIA_TYPE, reason);
    this.contentType = null;
    this.supportedMediaTypes = Collections.emptyList();
    this.bodyType = null;
}
org.springframework.web.server.UnsupportedMediaTypeStatusException
public UnsupportedMediaTypeStatusException UnsupportedMediaTypeStatusException(@Nullable MediaType contentType, List<MediaType> supportedTypes)
{
    this(contentType, supportedTypes, null);
}
org.springframework.web.server.UnsupportedMediaTypeStatusException
public UnsupportedMediaTypeStatusException UnsupportedMediaTypeStatusException(@Nullable MediaType contentType, List<MediaType> supportedTypes, @Nullable ResolvableType bodyType)
{
    super(HttpStatus.UNSUPPORTED_MEDIA_TYPE, initReason(contentType, bodyType));
    this.contentType = contentType;
    this.supportedMediaTypes = Collections.unmodifiableList(supportedTypes);
    this.bodyType = bodyType;
}
org.springframework.web.server.UnsupportedMediaTypeStatusException
@Nullable public ResolvableType getBodyType()
{
    return this.bodyType;
}
org.springframework.web.server.UnsupportedMediaTypeStatusException
@Nullable public MediaType getContentType()
{
    return this.contentType;
}
org.springframework.web.server.UnsupportedMediaTypeStatusException
public List<MediaType> getSupportedMediaTypes()
{
    return this.supportedMediaTypes;
}
 WebExceptionHandler
 WebFilter
 WebFilterChain
 WebHandler
 WebSession
 AbstractReactiveWebInitializer
 implements WebApplicationInitializer
org.springframework.web.server.adapter.AbstractReactiveWebInitializer
public static final String DEFAULT_SERVLET_NAME
org.springframework.web.server.adapter.AbstractReactiveWebInitializer
protected abstract Class<?>[] getConfigClasses()
org.springframework.web.server.adapter.AbstractReactiveWebInitializer
protected String getServletMapping()
{
    return "/";
}
org.springframework.web.server.adapter.AbstractReactiveWebInitializer
protected String getServletName()
{
    return DEFAULT_SERVLET_NAME;
}
org.springframework.web.server.adapter.AbstractReactiveWebInitializer
protected void refreshApplicationContext(ApplicationContext context)
{
    if (context instanceof ConfigurableApplicationContext) {
        ConfigurableApplicationContext cac = (ConfigurableApplicationContext)context;
        if (!cac.isActive()) {
            cac.refresh();
        } 
    } 
}
 DefaultServerWebExchange
 implements ServerWebExchange
org.springframework.web.server.adapter.DefaultServerWebExchange
public DefaultServerWebExchange DefaultServerWebExchange(ServerHttpRequest request, ServerHttpResponse response, WebSessionManager sessionManager, ServerCodecConfigurer codecConfigurer, LocaleContextResolver localeContextResolver)
{
    this(request, response, sessionManager, codecConfigurer, localeContextResolver, null);
}
org.springframework.web.server.adapter.DefaultServerWebExchange
@Override public void addUrlTransformer(Function<String, String> transformer)
{
    Assert.notNull(transformer, "'encoder' must not be null");
    this.urlTransformer = this.urlTransformer.andThen(transformer);
}
org.springframework.web.server.adapter.DefaultServerWebExchange
@Override public boolean checkNotModified(Instant lastModified)
{
    return checkNotModified(null, lastModified);
}
org.springframework.web.server.adapter.DefaultServerWebExchange
@Override public boolean checkNotModified(String etag)
{
    return checkNotModified(etag, Instant.MIN);
}
org.springframework.web.server.adapter.DefaultServerWebExchange
@Override public boolean checkNotModified(@Nullable String etag, Instant lastModified)
{
    HttpStatus status = getResponse().getStatusCode();
    if (this.notModified || (status != null && !HttpStatus.OK.equals(status))) {
        return this.notModified;
    } 
    if (validateIfUnmodifiedSince(lastModified)) {
        if (this.notModified) {
            getResponse().setStatusCode(HttpStatus.PRECONDITION_FAILED);
        } 
        return this.notModified;
    } 
    boolean validated = validateIfNoneMatch(etag);
    if (!validated) {
        validateIfModifiedSince(lastModified);
    } 
    boolean isHttpGetOrHead = SAFE_METHODS.contains(getRequest().getMethod());
    if (this.notModified) {
        getResponse().setStatusCode(isHttpGetOrHead ? HttpStatus.NOT_MODIFIED : HttpStatus.PRECONDITION_FAILED);
    } 
    if (isHttpGetOrHead) {
        if (lastModified.isAfter(Instant.EPOCH) && getResponseHeaders().getLastModified() == -1) {
            getResponseHeaders().setLastModified(lastModified.toEpochMilli());
        } 
        if (StringUtils.hasLength(etag) && getResponseHeaders().getETag() == null) {
            getResponseHeaders().setETag(padEtagIfNecessary(etag));
        } 
    } 
    return this.notModified;
}
org.springframework.web.server.adapter.DefaultServerWebExchange
@Override @Nullable public ApplicationContext getApplicationContext()
{
    return this.applicationContext;
}
org.springframework.web.server.adapter.DefaultServerWebExchange
@Override public Map<String, Object> getAttributes()
{
    return this.attributes;
}
org.springframework.web.server.adapter.DefaultServerWebExchange
@Override public Mono<MultiValueMap<String, String>> getFormData()
{
    return this.formDataMono;
}
org.springframework.web.server.adapter.DefaultServerWebExchange
@Override public LocaleContext getLocaleContext()
{
    return this.localeContextResolver.resolveLocaleContext(this);
}
org.springframework.web.server.adapter.DefaultServerWebExchange
@Override public String getLogPrefix()
{
    Object value = getAttribute(LOG_ID_ATTRIBUTE);
    if (this.logId != value) {
        this.logId = value;
        this.logPrefix = value != null ? "[" + value + "] " : "";
    } 
    return this.logPrefix;
}
org.springframework.web.server.adapter.DefaultServerWebExchange
@Override public Mono<MultiValueMap<String, Part>> getMultipartData()
{
    return this.multipartDataMono;
}
org.springframework.web.server.adapter.DefaultServerWebExchange
<T>@Override public Mono<T> getPrincipal()
{
    return Mono.empty();
}
org.springframework.web.server.adapter.DefaultServerWebExchange
@Override public ServerHttpRequest getRequest()
{
    return this.request;
}
org.springframework.web.server.adapter.DefaultServerWebExchange
@Override public ServerHttpResponse getResponse()
{
    return this.response;
}
org.springframework.web.server.adapter.DefaultServerWebExchange
@Override public Mono<WebSession> getSession()
{
    return this.sessionMono;
}
org.springframework.web.server.adapter.DefaultServerWebExchange
@Override public boolean isNotModified()
{
    return this.notModified;
}
org.springframework.web.server.adapter.DefaultServerWebExchange
volatile boolean notModified
org.springframework.web.server.adapter.DefaultServerWebExchange
@Override public String transformUrl(String url)
{
    return this.urlTransformer.apply(url);
}
 ForwardedHeaderTransformer
 implements Function<ServerHttpRequest, ServerHttpRequest>
org.springframework.web.server.adapter.ForwardedHeaderTransformer
protected boolean hasForwardedHeaders(ServerHttpRequest request)
{
    HttpHeaders headers = request.getHeaders();
    for (String headerName: FORWARDED_HEADER_NAMES) {
        if (headers.containsKey(headerName)) {
            return true;
        } 
    }
    return false;
}
org.springframework.web.server.adapter.ForwardedHeaderTransformer
public boolean isRemoveOnly()
{
    return this.removeOnly;
}
org.springframework.web.server.adapter.ForwardedHeaderTransformer
public void setRemoveOnly(boolean removeOnly)
{
    this.removeOnly = removeOnly;
}
 HttpWebHandlerAdapter
 extends WebHandlerDecorator implements HttpHandler
org.springframework.web.server.adapter.HttpWebHandlerAdapter
public HttpWebHandlerAdapter HttpWebHandlerAdapter(WebHandler delegate)
{
    super(delegate);
}
org.springframework.web.server.adapter.HttpWebHandlerAdapter
protected ServerWebExchange createExchange(ServerHttpRequest request, ServerHttpResponse response)
{
    return new DefaultServerWebExchange(request, response, this.sessionManager, getCodecConfigurer(), getLocaleContextResolver(), this.applicationContext);
}
org.springframework.web.server.adapter.HttpWebHandlerAdapter
@Nullable public ApplicationContext getApplicationContext()
{
    return this.applicationContext;
}
org.springframework.web.server.adapter.HttpWebHandlerAdapter
public ServerCodecConfigurer getCodecConfigurer()
{
    return this.codecConfigurer;
}
org.springframework.web.server.adapter.HttpWebHandlerAdapter
@Nullable public ForwardedHeaderTransformer getForwardedHeaderTransformer()
{
    return this.forwardedHeaderTransformer;
}
org.springframework.web.server.adapter.HttpWebHandlerAdapter
public LocaleContextResolver getLocaleContextResolver()
{
    return this.localeContextResolver;
}
org.springframework.web.server.adapter.HttpWebHandlerAdapter
public WebSessionManager getSessionManager()
{
    return this.sessionManager;
}
org.springframework.web.server.adapter.HttpWebHandlerAdapter
@Override public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response)
{
    if (this.forwardedHeaderTransformer != null) {
        request = this.forwardedHeaderTransformer.apply(request);
    } 
    ServerWebExchange exchange = createExchange(request, response);
    LogFormatUtils.traceDebug(logger, traceOn -> exchange.getLogPrefix() + formatRequest(exchange.getRequest()) + (traceOn ? ", headers=" + formatHeaders(exchange.getRequest().getHeaders()) : ""));
    return getDelegate().handle(exchange).doOnSuccess(aVoid -> logResponse(exchange)).onErrorResume(ex -> handleUnresolvedError(exchange, ex)).then(Mono.defer(response::setComplete));
}
org.springframework.web.server.adapter.HttpWebHandlerAdapter
public void setApplicationContext(ApplicationContext applicationContext)
{
    this.applicationContext = applicationContext;
}
org.springframework.web.server.adapter.HttpWebHandlerAdapter
public void setForwardedHeaderTransformer(ForwardedHeaderTransformer transformer)
{
    Assert.notNull(transformer, "ForwardedHeaderTransformer is required");
    this.forwardedHeaderTransformer = transformer;
}
org.springframework.web.server.adapter.HttpWebHandlerAdapter
public void setLocaleContextResolver(LocaleContextResolver resolver)
{
    Assert.notNull(resolver, "LocaleContextResolver is required");
    this.localeContextResolver = resolver;
}
org.springframework.web.server.adapter.HttpWebHandlerAdapter
public void setSessionManager(WebSessionManager sessionManager)
{
    Assert.notNull(sessionManager, "WebSessionManager must not be null");
    this.sessionManager = sessionManager;
}
 WebHttpHandlerBuilder
org.springframework.web.server.adapter.WebHttpHandlerBuilder
public static final String FORWARDED_HEADER_TRANSFORMER_BEAN_NAME
org.springframework.web.server.adapter.WebHttpHandlerBuilder
public static final String LOCALE_CONTEXT_RESOLVER_BEAN_NAME
org.springframework.web.server.adapter.WebHttpHandlerBuilder
public static final String SERVER_CODEC_CONFIGURER_BEAN_NAME
org.springframework.web.server.adapter.WebHttpHandlerBuilder
public static final String WEB_HANDLER_BEAN_NAME
org.springframework.web.server.adapter.WebHttpHandlerBuilder
public static final String WEB_SESSION_MANAGER_BEAN_NAME
org.springframework.web.server.adapter.WebHttpHandlerBuilder
@Override public WebHttpHandlerBuilder clone()
{
    return new WebHttpHandlerBuilder(this);
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder
public WebHttpHandlerBuilder codecConfigurer(ServerCodecConfigurer codecConfigurer)
{
    this.codecConfigurer = codecConfigurer;
    return this;
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder
public WebHttpHandlerBuilder exceptionHandler(WebExceptionHandler... handlers)
{
    if (!ObjectUtils.isEmpty(handlers)) {
        this.exceptionHandlers.addAll(Arrays.asList(handlers));
    } 
    return this;
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder
public WebHttpHandlerBuilder exceptionHandlers(Consumer<List<WebExceptionHandler>> consumer)
{
    consumer.accept(this.exceptionHandlers);
    return this;
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder
public WebHttpHandlerBuilder filter(WebFilter... filters)
{
    if (!ObjectUtils.isEmpty(filters)) {
        this.filters.addAll(Arrays.asList(filters));
        updateFilters();
    } 
    return this;
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder
public WebHttpHandlerBuilder filters(Consumer<List<WebFilter>> consumer)
{
    consumer.accept(this.filters);
    updateFilters();
    return this;
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder
public WebHttpHandlerBuilder forwardedHeaderTransformer(ForwardedHeaderTransformer transformer)
{
    this.forwardedHeaderTransformer = transformer;
    return this;
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder
public boolean hasCodecConfigurer()
{
    return (this.codecConfigurer != null);
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder
public boolean hasForwardedHeaderTransformer()
{
    return (this.forwardedHeaderTransformer != null);
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder
public boolean hasLocaleContextResolver()
{
    return (this.localeContextResolver != null);
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder
public boolean hasSessionManager()
{
    return (this.sessionManager != null);
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder
public WebHttpHandlerBuilder localeContextResolver(LocaleContextResolver localeContextResolver)
{
    this.localeContextResolver = localeContextResolver;
    return this;
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder
public WebHttpHandlerBuilder sessionManager(WebSessionManager manager)
{
    this.sessionManager = manager;
    return this;
}
org.springframework.web.server.adapter.WebHttpHandlerBuilder
public static WebHttpHandlerBuilder webHandler(WebHandler webHandler)
{
    return new WebHttpHandlerBuilder(webHandler, null);
}
 DefaultWebFilterChain
 implements WebFilterChain
org.springframework.web.server.handler.DefaultWebFilterChain
@Deprecated public DefaultWebFilterChain DefaultWebFilterChain(WebHandler handler, WebFilter... filters)
{
    this(handler, Arrays.asList(filters));
}
org.springframework.web.server.handler.DefaultWebFilterChain
@Override public Mono<Void> filter(ServerWebExchange exchange)
{
    return Mono.defer(() -> this.currentFilter != null && this.chain != null ? invokeFilter(this.currentFilter, this.chain, exchange) : this.handler.handle(exchange));
}
org.springframework.web.server.handler.DefaultWebFilterChain
public List<WebFilter> getFilters()
{
    return this.allFilters;
}
org.springframework.web.server.handler.DefaultWebFilterChain
public WebHandler getHandler()
{
    return this.handler;
}
 ExceptionHandlingWebHandler
 extends WebHandlerDecorator
org.springframework.web.server.handler.ExceptionHandlingWebHandler
public ExceptionHandlingWebHandler ExceptionHandlingWebHandler(WebHandler delegate, List<WebExceptionHandler> handlers)
{
    super(delegate);
    List<WebExceptionHandler> handlersToUse = new ArrayList<>();
    handlersToUse.add(new CheckpointInsertingHandler());
    handlersToUse.addAll(handlers);
    this.exceptionHandlers = Collections.unmodifiableList(handlersToUse);
}
org.springframework.web.server.handler.ExceptionHandlingWebHandler
public List<WebExceptionHandler> getExceptionHandlers()
{
    return this.exceptionHandlers;
}
org.springframework.web.server.handler.ExceptionHandlingWebHandler
@Override public Mono<Void> handle(ServerWebExchange exchange)
{
    Mono < Void > completion;
    try {
        completion = super.handle(exchange);
    } catch (Throwable ex) {
        completion = Mono.error(ex);
    }
    for (WebExceptionHandler handler: this.exceptionHandlers) {
        completion = completion.onErrorResume(ex -> handler.handle(exchange, ex));
    }
    return completion;
}
 FilteringWebHandler
 extends WebHandlerDecorator
org.springframework.web.server.handler.FilteringWebHandler
public FilteringWebHandler FilteringWebHandler(WebHandler handler, List<WebFilter> filters)
{
    super(handler);
    this.chain = new DefaultWebFilterChain(handler, filters);
}
org.springframework.web.server.handler.FilteringWebHandler
public List<WebFilter> getFilters()
{
    return this.chain.getFilters();
}
org.springframework.web.server.handler.FilteringWebHandler
@Override public Mono<Void> handle(ServerWebExchange exchange)
{
    return this.chain.filter(exchange);
}
 ResponseStatusExceptionHandler
 implements WebExceptionHandler
org.springframework.web.server.handler.ResponseStatusExceptionHandler
@Nullable protected HttpStatus determineStatus(Throwable ex)
{
    if (ex instanceof ResponseStatusException) {
        return ((ResponseStatusException)ex).getStatus();
    } 
    return null;
}
org.springframework.web.server.handler.ResponseStatusExceptionHandler
@Override public Mono<Void> handle(ServerWebExchange exchange, Throwable ex)
{
    HttpStatus status = resolveStatus(ex);
    if (status == null || !exchange.getResponse().setStatusCode(status)) {
        return Mono.error(ex);
    } 
    String logPrefix = exchange.getLogPrefix();
    if (this.warnLogger != null && this.warnLogger.isWarnEnabled()) {
        this.warnLogger.warn(logPrefix + formatError(ex, exchange.getRequest()), ex);
    } else if (logger.isDebugEnabled()) {
        logger.debug(logPrefix + formatError(ex, exchange.getRequest()));
    } 
    return exchange.getResponse().setComplete();
}
org.springframework.web.server.handler.ResponseStatusExceptionHandler
public void setWarnLogCategory(String loggerName)
{
    this.warnLogger = LogFactory.getLog(loggerName);
}
 WebHandlerDecorator
 implements WebHandler
org.springframework.web.server.handler.WebHandlerDecorator
public WebHandlerDecorator WebHandlerDecorator(WebHandler delegate)
{
    Assert.notNull(delegate, "'delegate' must not be null");
    this.delegate = delegate;
}
org.springframework.web.server.handler.WebHandlerDecorator
public WebHandler getDelegate()
{
    return this.delegate;
}
org.springframework.web.server.handler.WebHandlerDecorator
@Override public Mono<Void> handle(ServerWebExchange exchange)
{
    return this.delegate.handle(exchange);
}
org.springframework.web.server.handler.WebHandlerDecorator
@Override public String toString()
{
    return getClass().getSimpleName() + " [delegate=" + this.delegate + "]";
}
 AcceptHeaderLocaleContextResolver
 implements LocaleContextResolver
org.springframework.web.server.i18n.AcceptHeaderLocaleContextResolver
@Nullable public Locale getDefaultLocale()
{
    return this.defaultLocale;
}
org.springframework.web.server.i18n.AcceptHeaderLocaleContextResolver
public List<Locale> getSupportedLocales()
{
    return this.supportedLocales;
}
org.springframework.web.server.i18n.AcceptHeaderLocaleContextResolver
@Override public LocaleContext resolveLocaleContext(ServerWebExchange exchange)
{
    List<Locale> requestLocales = null;
    try {
        requestLocales = exchange.getRequest().getHeaders().getAcceptLanguageAsLocales();
    } catch (IllegalArgumentException ex) {
    }
    return new SimpleLocaleContext(resolveSupportedLocale(requestLocales));
}
org.springframework.web.server.i18n.AcceptHeaderLocaleContextResolver
public void setDefaultLocale(@Nullable Locale defaultLocale)
{
    this.defaultLocale = defaultLocale;
}
org.springframework.web.server.i18n.AcceptHeaderLocaleContextResolver
@Override public void setLocaleContext(ServerWebExchange exchange, @Nullable LocaleContext locale)
{
    throw new UnsupportedOperationException("Cannot change HTTP accept header - use a different locale context resolution strategy");
}
org.springframework.web.server.i18n.AcceptHeaderLocaleContextResolver
public void setSupportedLocales(List<Locale> locales)
{
    this.supportedLocales.clear();
    this.supportedLocales.addAll(locales);
}
 FixedLocaleContextResolver
 implements LocaleContextResolver
org.springframework.web.server.i18n.FixedLocaleContextResolver
public FixedLocaleContextResolver FixedLocaleContextResolver()
{
    this(Locale.getDefault());
}
org.springframework.web.server.i18n.FixedLocaleContextResolver
public FixedLocaleContextResolver FixedLocaleContextResolver(Locale locale)
{
    this(locale, null);
}
org.springframework.web.server.i18n.FixedLocaleContextResolver
public FixedLocaleContextResolver FixedLocaleContextResolver(Locale locale, @Nullable TimeZone timeZone)
{
    Assert.notNull(locale, "Locale must not be null");
    this.locale = locale;
    this.timeZone = timeZone;
}
org.springframework.web.server.i18n.FixedLocaleContextResolver
@Override public LocaleContext resolveLocaleContext(ServerWebExchange exchange)
{
    return new TimeZoneAwareLocaleContext() {
        @Override
        public Locale getLocale() {
            return locale;
        }
        @Override
        @Nullable
        public TimeZone getTimeZone() {
            return timeZone;
        }
    };
}
org.springframework.web.server.i18n.FixedLocaleContextResolver
@Override public void setLocaleContext(ServerWebExchange exchange, @Nullable LocaleContext localeContext)
{
    throw new UnsupportedOperationException("Cannot change fixed locale - use a different locale context resolution strategy");
}
 LocaleContextResolver
 CookieWebSessionIdResolver
 implements WebSessionIdResolver
org.springframework.web.server.session.CookieWebSessionIdResolver
public void addCookieInitializer(Consumer<ResponseCookie.ResponseCookieBuilder> initializer)
{
    this.cookieInitializer = this.cookieInitializer != null ? this.cookieInitializer.andThen(initializer) : initializer;
}
org.springframework.web.server.session.CookieWebSessionIdResolver
@Override public void expireSession(ServerWebExchange exchange)
{
    ResponseCookie cookie = initSessionCookie(exchange, "", Duration.ZERO);
    exchange.getResponse().getCookies().set(this.cookieName, cookie);
}
org.springframework.web.server.session.CookieWebSessionIdResolver
public Duration getCookieMaxAge()
{
    return this.cookieMaxAge;
}
org.springframework.web.server.session.CookieWebSessionIdResolver
public String getCookieName()
{
    return this.cookieName;
}
org.springframework.web.server.session.CookieWebSessionIdResolver
@Override public List<String> resolveSessionIds(ServerWebExchange exchange)
{
    MultiValueMap<String, HttpCookie> cookieMap = exchange.getRequest().getCookies();
    List<HttpCookie> cookies = cookieMap.get(getCookieName());
    if (cookies == null) {
        return Collections.emptyList();
    } 
    return cookies.stream().map(HttpCookie::getValue).collect(Collectors.toList());
}
org.springframework.web.server.session.CookieWebSessionIdResolver
public void setCookieMaxAge(Duration maxAge)
{
    this.cookieMaxAge = maxAge;
}
org.springframework.web.server.session.CookieWebSessionIdResolver
public void setCookieName(String cookieName)
{
    Assert.hasText(cookieName, "'cookieName' must not be empty");
    this.cookieName = cookieName;
}
org.springframework.web.server.session.CookieWebSessionIdResolver
@Override public void setSessionId(ServerWebExchange exchange, String id)
{
    Assert.notNull(id, "'id' is required");
    ResponseCookie cookie = initSessionCookie(exchange, id, getCookieMaxAge());
    exchange.getResponse().getCookies().set(this.cookieName, cookie);
}
 DefaultWebSessionManager
 implements WebSessionManager
org.springframework.web.server.session.DefaultWebSessionManager
@Override public Mono<WebSession> getSession(ServerWebExchange exchange)
{
    return Mono.defer(() -> retrieveSession(exchange).switchIfEmpty(this.sessionStore.createWebSession()).doOnNext(session -> exchange.getResponse().beforeCommit(() -> save(exchange, session))));
}
org.springframework.web.server.session.DefaultWebSessionManager
public WebSessionIdResolver getSessionIdResolver()
{
    return this.sessionIdResolver;
}
org.springframework.web.server.session.DefaultWebSessionManager
public WebSessionStore getSessionStore()
{
    return this.sessionStore;
}
org.springframework.web.server.session.DefaultWebSessionManager
public void setSessionIdResolver(WebSessionIdResolver sessionIdResolver)
{
    Assert.notNull(sessionIdResolver, "WebSessionIdResolver is required");
    this.sessionIdResolver = sessionIdResolver;
}
org.springframework.web.server.session.DefaultWebSessionManager
public void setSessionStore(WebSessionStore sessionStore)
{
    Assert.notNull(sessionStore, "WebSessionStore is required");
    this.sessionStore = sessionStore;
}
 HeaderWebSessionIdResolver
 implements WebSessionIdResolver
org.springframework.web.server.session.HeaderWebSessionIdResolver
public static final String DEFAULT_HEADER_NAME
org.springframework.web.server.session.HeaderWebSessionIdResolver
@Override public void expireSession(ServerWebExchange exchange)
{
    this.setSessionId(exchange, "");
}
org.springframework.web.server.session.HeaderWebSessionIdResolver
public String getHeaderName()
{
    return this.headerName;
}
org.springframework.web.server.session.HeaderWebSessionIdResolver
@Override public List<String> resolveSessionIds(ServerWebExchange exchange)
{
    HttpHeaders headers = exchange.getRequest().getHeaders();
    return headers.getOrDefault(getHeaderName(), Collections.emptyList());
}
org.springframework.web.server.session.HeaderWebSessionIdResolver
public void setHeaderName(String headerName)
{
    Assert.hasText(headerName, "'headerName' must not be empty");
    this.headerName = headerName;
}
org.springframework.web.server.session.HeaderWebSessionIdResolver
@Override public void setSessionId(ServerWebExchange exchange, String id)
{
    Assert.notNull(id, "'id' is required.");
    exchange.getResponse().getHeaders().set(getHeaderName(), id);
}
 InMemoryWebSessionStore
 implements WebSessionStore
org.springframework.web.server.session.InMemoryWebSessionStore
@Override public Mono<WebSession> createWebSession()
{
    Instant now = this.clock.instant();
    this.expiredSessionChecker.checkIfNecessary(now);
    return Mono.fromSupplier(() -> new InMemoryWebSession(now));
}
org.springframework.web.server.session.InMemoryWebSessionStore
public Clock getClock()
{
    return this.clock;
}
org.springframework.web.server.session.InMemoryWebSessionStore
public int getMaxSessions()
{
    return this.maxSessions;
}
org.springframework.web.server.session.InMemoryWebSessionStore
public Map<String, WebSession> getSessions()
{
    return Collections.unmodifiableMap(this.sessions);
}
org.springframework.web.server.session.InMemoryWebSessionStore
public void removeExpiredSessions()
{
    this.expiredSessionChecker.removeExpiredSessions(this.clock.instant());
}
org.springframework.web.server.session.InMemoryWebSessionStore
@Override public Mono<Void> removeSession(String id)
{
    this.sessions.remove(id);
    return Mono.empty();
}
org.springframework.web.server.session.InMemoryWebSessionStore
public void setClock(Clock clock)
{
    Assert.notNull(clock, "Clock is required");
    this.clock = clock;
    removeExpiredSessions();
}
org.springframework.web.server.session.InMemoryWebSessionStore
public void setMaxSessions(int maxSessions)
{
    this.maxSessions = maxSessions;
}
org.springframework.web.server.session.InMemoryWebSessionStore
@Override public Mono<WebSession> updateLastAccessTime(WebSession session)
{
    return Mono.fromSupplier(() -> {
        Assert.isInstanceOf(InMemoryWebSession.class, session);
        ((InMemoryWebSession)session).updateLastAccessTime(this.clock.instant());
        return session;
    });
}
 WebSessionIdResolver
 WebSessionManager
 WebSessionStore
 AbstractUriTemplateHandler
 implements UriTemplateHandler
org.springframework.web.util.AbstractUriTemplateHandler
@Override public URI expand(String uriTemplate, Map<String, ?> uriVariables)
{
    if (!getDefaultUriVariables().isEmpty()) {
        Map<String, Object> map = new HashMap<>();
        map.putAll(getDefaultUriVariables());
        map.putAll(uriVariables);
        uriVariables = map;
    } 
    URI url = expandInternal(uriTemplate, uriVariables);
    return insertBaseUrl(url);
}
org.springframework.web.util.AbstractUriTemplateHandler
@Override public URI expand(String uriTemplate, Object... uriVariables)
{
    URI url = expandInternal(uriTemplate, uriVariables);
    return insertBaseUrl(url);
}
org.springframework.web.util.AbstractUriTemplateHandler
protected abstract URI expandInternal(String uriTemplate, Map<String, ?> uriVariables)
org.springframework.web.util.AbstractUriTemplateHandler
protected abstract URI expandInternal(String uriTemplate, Object... uriVariables)
org.springframework.web.util.AbstractUriTemplateHandler
@Nullable public String getBaseUrl()
{
    return this.baseUrl;
}
org.springframework.web.util.AbstractUriTemplateHandler
public Map<String, ?> getDefaultUriVariables()
{
    return Collections.unmodifiableMap(this.defaultUriVariables);
}
org.springframework.web.util.AbstractUriTemplateHandler
public void setDefaultUriVariables(@Nullable Map<String, ?> defaultUriVariables)
{
    this.defaultUriVariables.clear();
    if (defaultUriVariables != null) {
        this.defaultUriVariables.putAll(defaultUriVariables);
    } 
}
 ContentCachingRequestWrapper
 extends HttpServletRequestWrapper
org.springframework.web.util.ContentCachingRequestWrapper
public ContentCachingRequestWrapper ContentCachingRequestWrapper(HttpServletRequest request)
{
    super(request);
    int contentLength = request.getContentLength();
    this.cachedContent = new ByteArrayOutputStream(contentLength >= 0 ? contentLength : 1024);
    this.contentCacheLimit = null;
}
org.springframework.web.util.ContentCachingRequestWrapper
public ContentCachingRequestWrapper ContentCachingRequestWrapper(HttpServletRequest request, int contentCacheLimit)
{
    super(request);
    this.cachedContent = new ByteArrayOutputStream(contentCacheLimit);
    this.contentCacheLimit = contentCacheLimit;
}
org.springframework.web.util.ContentCachingRequestWrapper
@Override public String getCharacterEncoding()
{
    String enc = super.getCharacterEncoding();
    return (enc != null ? enc : WebUtils.DEFAULT_CHARACTER_ENCODING);
}
org.springframework.web.util.ContentCachingRequestWrapper
public byte[] getContentAsByteArray()
{
    return this.cachedContent.toByteArray();
}
org.springframework.web.util.ContentCachingRequestWrapper
@Override public ServletInputStream getInputStream()
{
    if (this.inputStream == null) {
        this.inputStream = new ContentCachingInputStream(getRequest().getInputStream());
    } 
    return this.inputStream;
}
org.springframework.web.util.ContentCachingRequestWrapper
@Override public String getParameter(String name)
{
    if (this.cachedContent.size() == 0 && isFormPost()) {
        writeRequestParametersToCachedContent();
    } 
    return super.getParameter(name);
}
org.springframework.web.util.ContentCachingRequestWrapper
@Override public Map<String, String[]> getParameterMap()
{
    if (this.cachedContent.size() == 0 && isFormPost()) {
        writeRequestParametersToCachedContent();
    } 
    return super.getParameterMap();
}
org.springframework.web.util.ContentCachingRequestWrapper
@Override public Enumeration<String> getParameterNames()
{
    if (this.cachedContent.size() == 0 && isFormPost()) {
        writeRequestParametersToCachedContent();
    } 
    return super.getParameterNames();
}
org.springframework.web.util.ContentCachingRequestWrapper
@Override public String[] getParameterValues(String name)
{
    if (this.cachedContent.size() == 0 && isFormPost()) {
        writeRequestParametersToCachedContent();
    } 
    return super.getParameterValues(name);
}
org.springframework.web.util.ContentCachingRequestWrapper
@Override public BufferedReader getReader()
{
    if (this.reader == null) {
        this.reader = new BufferedReader(new InputStreamReader(getInputStream(), getCharacterEncoding()));
    } 
    return this.reader;
}
org.springframework.web.util.ContentCachingRequestWrapper
protected void handleContentOverflow(int contentCacheLimit)
{
}
 ContentCachingResponseWrapper
 extends HttpServletResponseWrapper
org.springframework.web.util.ContentCachingResponseWrapper
public ContentCachingResponseWrapper ContentCachingResponseWrapper(HttpServletResponse response)
{
    super(response);
}
org.springframework.web.util.ContentCachingResponseWrapper
public void copyBodyToResponse()
{
    copyBodyToResponse(true);
}
org.springframework.web.util.ContentCachingResponseWrapper
@Override public void flushBuffer()
{
}
org.springframework.web.util.ContentCachingResponseWrapper
public byte[] getContentAsByteArray()
{
    return this.content.toByteArray();
}
org.springframework.web.util.ContentCachingResponseWrapper
public InputStream getContentInputStream()
{
    return this.content.getInputStream();
}
org.springframework.web.util.ContentCachingResponseWrapper
public int getContentSize()
{
    return this.content.size();
}
org.springframework.web.util.ContentCachingResponseWrapper
@Override public ServletOutputStream getOutputStream()
{
    if (this.outputStream == null) {
        this.outputStream = new ResponseServletOutputStream(getResponse().getOutputStream());
    } 
    return this.outputStream;
}
org.springframework.web.util.ContentCachingResponseWrapper
@Deprecated public int getStatusCode()
{
    return getStatus();
}
org.springframework.web.util.ContentCachingResponseWrapper
@Override public void reset()
{
    super.reset();
    this.content.reset();
}
org.springframework.web.util.ContentCachingResponseWrapper
@Override public void resetBuffer()
{
    this.content.reset();
}
org.springframework.web.util.ContentCachingResponseWrapper
@Override public void sendError(int sc)
{
    copyBodyToResponse(false);
    try {
        super.sendError(sc);
    } catch (IllegalStateException ex) {
        super.setStatus(sc);
    }
}
org.springframework.web.util.ContentCachingResponseWrapper
@Override @SuppressWarnings("deprecation") public void sendError(int sc, String msg)
{
    copyBodyToResponse(false);
    try {
        super.sendError(sc, msg);
    } catch (IllegalStateException ex) {
        super.setStatus(sc, msg);
    }
}
org.springframework.web.util.ContentCachingResponseWrapper
@Override public void sendRedirect(String location)
{
    copyBodyToResponse(false);
    super.sendRedirect(location);
}
org.springframework.web.util.ContentCachingResponseWrapper
@Override public void setBufferSize(int size)
{
    if (size > this.content.size()) {
        this.content.resize(size);
    } 
}
org.springframework.web.util.ContentCachingResponseWrapper
@Override public void setContentLength(int len)
{
    if (len > this.content.size()) {
        this.content.resize(len);
    } 
    this.contentLength = len;
}
org.springframework.web.util.ContentCachingResponseWrapper
@Override public void setContentLengthLong(long len)
{
    if (len > Integer.MAX_VALUE) {
        throw new IllegalArgumentException("Content-Length exceeds ContentCachingResponseWrapper's maximum (" + Integer.MAX_VALUE + "): " + len);
    } 
    int lenInt = (int)len;
    if (lenInt > this.content.size()) {
        this.content.resize(lenInt);
    } 
    this.contentLength = lenInt;
}
 CookieGenerator
org.springframework.web.util.CookieGenerator
public void addCookie(HttpServletResponse response, String cookieValue)
{
    Assert.notNull(response, "HttpServletResponse must not be null");
    Cookie cookie = createCookie(cookieValue);
    Integer maxAge = getCookieMaxAge();
    if (maxAge != null) {
        cookie.setMaxAge(maxAge);
    } 
    if (isCookieSecure()) {
        cookie.setSecure(true);
    } 
    if (isCookieHttpOnly()) {
        cookie.setHttpOnly(true);
    } 
    response.addCookie(cookie);
    if (logger.isTraceEnabled()) {
        logger.trace("Added cookie [" + getCookieName() + "=" + cookieValue + "]");
    } 
}
org.springframework.web.util.CookieGenerator
protected Cookie createCookie(String cookieValue)
{
    Cookie cookie = new Cookie(getCookieName(), cookieValue);
    if (getCookieDomain() != null) {
        cookie.setDomain(getCookieDomain());
    } 
    cookie.setPath(getCookiePath());
    return cookie;
}
org.springframework.web.util.CookieGenerator
@Nullable public String getCookieDomain()
{
    return this.cookieDomain;
}
org.springframework.web.util.CookieGenerator
@Nullable public Integer getCookieMaxAge()
{
    return this.cookieMaxAge;
}
org.springframework.web.util.CookieGenerator
@Nullable public String getCookieName()
{
    return this.cookieName;
}
org.springframework.web.util.CookieGenerator
public String getCookiePath()
{
    return this.cookiePath;
}
org.springframework.web.util.CookieGenerator
public boolean isCookieHttpOnly()
{
    return this.cookieHttpOnly;
}
org.springframework.web.util.CookieGenerator
public boolean isCookieSecure()
{
    return this.cookieSecure;
}
org.springframework.web.util.CookieGenerator
protected final Log logger
org.springframework.web.util.CookieGenerator
public void removeCookie(HttpServletResponse response)
{
    Assert.notNull(response, "HttpServletResponse must not be null");
    Cookie cookie = createCookie("");
    cookie.setMaxAge(0);
    if (isCookieSecure()) {
        cookie.setSecure(true);
    } 
    if (isCookieHttpOnly()) {
        cookie.setHttpOnly(true);
    } 
    response.addCookie(cookie);
    if (logger.isTraceEnabled()) {
        logger.trace("Removed cookie '" + getCookieName() + "'");
    } 
}
org.springframework.web.util.CookieGenerator
public void setCookieDomain(@Nullable String cookieDomain)
{
    this.cookieDomain = cookieDomain;
}
org.springframework.web.util.CookieGenerator
public void setCookieHttpOnly(boolean cookieHttpOnly)
{
    this.cookieHttpOnly = cookieHttpOnly;
}
org.springframework.web.util.CookieGenerator
public void setCookieMaxAge(@Nullable Integer cookieMaxAge)
{
    this.cookieMaxAge = cookieMaxAge;
}
org.springframework.web.util.CookieGenerator
public void setCookieName(@Nullable String cookieName)
{
    this.cookieName = cookieName;
}
org.springframework.web.util.CookieGenerator
public void setCookiePath(String cookiePath)
{
    this.cookiePath = cookiePath;
}
org.springframework.web.util.CookieGenerator
public void setCookieSecure(boolean cookieSecure)
{
    this.cookieSecure = cookieSecure;
}
 DefaultUriBuilderFactory
 implements UriBuilderFactory
org.springframework.web.util.DefaultUriBuilderFactory
public DefaultUriBuilderFactory DefaultUriBuilderFactory()
{
    this.baseUri = null;
}
org.springframework.web.util.DefaultUriBuilderFactory
public DefaultUriBuilderFactory DefaultUriBuilderFactory(String baseUriTemplate)
{
    this.baseUri = UriComponentsBuilder.fromUriString(baseUriTemplate);
}
org.springframework.web.util.DefaultUriBuilderFactory
public DefaultUriBuilderFactory DefaultUriBuilderFactory(UriComponentsBuilder baseUri)
{
    this.baseUri = baseUri;
}
EncodingMode
enum values
  • TEMPLATE_AND_VALUES
  • VALUES_ONLY
  • URI_COMPONENT
  • NONE
org.springframework.web.util.DefaultUriBuilderFactory
@Override public UriBuilder builder()
{
    return new DefaultUriBuilder("");
}
org.springframework.web.util.DefaultUriBuilderFactory
@Override public URI expand(String uriTemplate, Map<String, ?> uriVars)
{
    return uriString(uriTemplate).build(uriVars);
}
org.springframework.web.util.DefaultUriBuilderFactory
@Override public URI expand(String uriTemplate, Object... uriVars)
{
    return uriString(uriTemplate).build(uriVars);
}
org.springframework.web.util.DefaultUriBuilderFactory
public Map<String, ?> getDefaultUriVariables()
{
    return Collections.unmodifiableMap(this.defaultUriVariables);
}
org.springframework.web.util.DefaultUriBuilderFactory
public EncodingMode getEncodingMode()
{
    return this.encodingMode;
}
org.springframework.web.util.DefaultUriBuilderFactory
public void setDefaultUriVariables(@Nullable Map<String, ?> defaultUriVariables)
{
    this.defaultUriVariables.clear();
    if (defaultUriVariables != null) {
        this.defaultUriVariables.putAll(defaultUriVariables);
    } 
}
org.springframework.web.util.DefaultUriBuilderFactory
public void setEncodingMode(EncodingMode encodingMode)
{
    this.encodingMode = encodingMode;
}
org.springframework.web.util.DefaultUriBuilderFactory
public void setParsePath(boolean parsePath)
{
    this.parsePath = parsePath;
}
org.springframework.web.util.DefaultUriBuilderFactory
public boolean shouldParsePath()
{
    return this.parsePath;
}
org.springframework.web.util.DefaultUriBuilderFactory
@Override public UriBuilder uriString(String uriTemplate)
{
    return new DefaultUriBuilder(uriTemplate);
}
 DefaultUriTemplateHandler
 extends AbstractUriTemplateHandler
org.springframework.web.util.DefaultUriTemplateHandler
protected UriComponents expandAndEncode(UriComponentsBuilder builder, Map<String, ?> uriVariables)
{
    if (!isStrictEncoding()) {
        return builder.buildAndExpand(uriVariables).encode();
    } else {
        Map<String, ?> encodedUriVars = UriUtils.encodeUriVariables(uriVariables);
        return builder.buildAndExpand(encodedUriVars);
    }
}
org.springframework.web.util.DefaultUriTemplateHandler
protected UriComponents expandAndEncode(UriComponentsBuilder builder, Object[] uriVariables)
{
    if (!isStrictEncoding()) {
        return builder.buildAndExpand(uriVariables).encode();
    } else {
        Object[] encodedUriVars = UriUtils.encodeUriVariables(uriVariables);
        return builder.buildAndExpand(encodedUriVars);
    }
}
org.springframework.web.util.DefaultUriTemplateHandler
@Override protected URI expandInternal(String uriTemplate, Map<String, ?> uriVariables)
{
    UriComponentsBuilder uriComponentsBuilder = initUriComponentsBuilder(uriTemplate);
    UriComponents uriComponents = expandAndEncode(uriComponentsBuilder, uriVariables);
    return createUri(uriComponents);
}
org.springframework.web.util.DefaultUriTemplateHandler
@Override protected URI expandInternal(String uriTemplate, Object... uriVariables)
{
    UriComponentsBuilder uriComponentsBuilder = initUriComponentsBuilder(uriTemplate);
    UriComponents uriComponents = expandAndEncode(uriComponentsBuilder, uriVariables);
    return createUri(uriComponents);
}
org.springframework.web.util.DefaultUriTemplateHandler
public boolean isStrictEncoding()
{
    return this.strictEncoding;
}
org.springframework.web.util.DefaultUriTemplateHandler
public void setParsePath(boolean parsePath)
{
    this.parsePath = parsePath;
}
org.springframework.web.util.DefaultUriTemplateHandler
public void setStrictEncoding(boolean strictEncoding)
{
    this.strictEncoding = strictEncoding;
}
org.springframework.web.util.DefaultUriTemplateHandler
public boolean shouldParsePath()
{
    return this.parsePath;
}
 HierarchicalUriComponents
 extends UriComponents
org.springframework.web.util.HierarchicalUriComponents
@Override protected void copyToUriComponentsBuilder(UriComponentsBuilder builder)
{
    if (getScheme() != null) {
        builder.scheme(getScheme());
    } 
    if (getUserInfo() != null) {
        builder.userInfo(getUserInfo());
    } 
    if (getHost() != null) {
        builder.host(getHost());
    } 
    if (this.port != null) {
        builder.port(this.port);
    } 
    this.path.copyToUriComponentsBuilder(builder);
    if (!getQueryParams().isEmpty()) {
        builder.queryParams(getQueryParams());
    } 
    if (getFragment() != null) {
        builder.fragment(getFragment());
    } 
}
org.springframework.web.util.HierarchicalUriComponents
@Override public HierarchicalUriComponents encode(Charset charset)
{
    if (this.encodeState.isEncoded()) {
        return this;
    } 
    String scheme = getScheme();
    String fragment = getFragment();
    String schemeTo = (scheme != null ? encodeUriComponent(scheme, charset, Type.SCHEME) : null);
    String fragmentTo = (fragment != null ? encodeUriComponent(fragment, charset, Type.FRAGMENT) : null);
    String userInfoTo = (this.userInfo != null ? encodeUriComponent(this.userInfo, charset, Type.USER_INFO) : null);
    String hostTo = (this.host != null ? encodeUriComponent(this.host, charset, getHostType()) : null);
    BiFunction<String, Type, String> encoder = (s, type) -> encodeUriComponent(s, charset, type);
    PathComponent pathTo = this.path.encode(encoder);
    MultiValueMap<String, String> queryParamsTo = encodeQueryParams(encoder);
    return new HierarchicalUriComponents(schemeTo, fragmentTo, userInfoTo, hostTo, this.port, pathTo, queryParamsTo, EncodeState.FULLY_ENCODED, null);
}
org.springframework.web.util.HierarchicalUriComponents
@Override public boolean equals(@Nullable Object other)
{
    if (this == other) {
        return true;
    } 
    if (!(other instanceof HierarchicalUriComponents)) {
        return false;
    } 
    HierarchicalUriComponents otherComp = (HierarchicalUriComponents)other;
    return (ObjectUtils.nullSafeEquals(getScheme(), otherComp.getScheme()) && ObjectUtils.nullSafeEquals(getUserInfo(), otherComp.getUserInfo()) && ObjectUtils.nullSafeEquals(getHost(), otherComp.getHost()) && getPort() == otherComp.getPort() && this.path.equals(otherComp.path) && this.queryParams.equals(otherComp.queryParams) && ObjectUtils.nullSafeEquals(getFragment(), otherComp.getFragment()));
}
org.springframework.web.util.HierarchicalUriComponents
@Override @Nullable public String getHost()
{
    return this.host;
}
org.springframework.web.util.HierarchicalUriComponents
@Override @NonNull public String getPath()
{
    return this.path.getPath();
}
org.springframework.web.util.HierarchicalUriComponents
@Override public List<String> getPathSegments()
{
    return this.path.getPathSegments();
}
org.springframework.web.util.HierarchicalUriComponents
@Override public int getPort()
{
    if (this.port == null) {
        return -1;
    } else if (this.port.contains("{")) {
        throw new IllegalStateException("The port contains a URI variable but has not been expanded yet: " + this.port);
    } 
    return Integer.parseInt(this.port);
}
org.springframework.web.util.HierarchicalUriComponents
@Override public MultiValueMap<String, String> getQueryParams()
{
    return this.queryParams;
}
org.springframework.web.util.HierarchicalUriComponents
@Override @Nullable public String getSchemeSpecificPart()
{
    return null;
}
org.springframework.web.util.HierarchicalUriComponents
@Override @Nullable public String getUserInfo()
{
    return this.userInfo;
}
org.springframework.web.util.HierarchicalUriComponents
@Override public String toUriString()
{
    StringBuilder uriBuilder = new StringBuilder();
    if (getScheme() != null) {
        uriBuilder.append(getScheme()).append(':');
    } 
    if (this.userInfo != null || this.host != null) {
        uriBuilder.append("//");
        if (this.userInfo != null) {
            uriBuilder.append(this.userInfo).append('@');
        } 
        if (this.host != null) {
            uriBuilder.append(this.host);
        } 
        if (getPort() != -1) {
            uriBuilder.append(':').append(this.port);
        } 
    } 
    String path = getPath();
    if (StringUtils.hasLength(path)) {
        if (uriBuilder.length() != 0 && path.charAt(0) != PATH_DELIMITER) {
            uriBuilder.append(PATH_DELIMITER);
        } 
        uriBuilder.append(path);
    } 
    String query = getQuery();
    if (query != null) {
        uriBuilder.append('?').append(query);
    } 
    if (getFragment() != null) {
        uriBuilder.append('#').append(getFragment());
    } 
    return uriBuilder.toString();
}
 HtmlCharacterEntityDecoder
org.springframework.web.util.HtmlCharacterEntityDecoder
public HtmlCharacterEntityDecoder HtmlCharacterEntityDecoder(HtmlCharacterEntityReferences characterEntityReferences, String original)
{
    this.characterEntityReferences = characterEntityReferences;
    this.originalMessage = original;
    this.decodedMessage = new StringBuilder(original.length());
}
 HtmlCharacterEntityReferences
org.springframework.web.util.HtmlCharacterEntityReferences
public char convertToCharacter(String entityReference)
{
    Character referredCharacter = this.entityReferenceToCharacterMap.get(entityReference);
    if (referredCharacter != null) {
        return referredCharacter;
    } 
    return CHAR_NULL;
}
org.springframework.web.util.HtmlCharacterEntityReferences
@Nullable public String convertToReference(char character)
{
    return convertToReference(character, WebUtils.DEFAULT_CHARACTER_ENCODING);
}
org.springframework.web.util.HtmlCharacterEntityReferences
public int getSupportedReferenceCount()
{
    return this.entityReferenceToCharacterMap.size();
}
org.springframework.web.util.HtmlCharacterEntityReferences
public boolean isMappedToReference(char character)
{
    return isMappedToReference(character, WebUtils.DEFAULT_CHARACTER_ENCODING);
}
org.springframework.web.util.HtmlCharacterEntityReferences
public boolean isMappedToReference(char character, String encoding)
{
    return (convertToReference(character, encoding) != null);
}
 HtmlUtils
org.springframework.web.util.HtmlUtils
public static String htmlEscape(String input)
{
    return htmlEscape(input, WebUtils.DEFAULT_CHARACTER_ENCODING);
}
org.springframework.web.util.HtmlUtils
public static String htmlEscapeDecimal(String input)
{
    return htmlEscapeDecimal(input, WebUtils.DEFAULT_CHARACTER_ENCODING);
}
org.springframework.web.util.HtmlUtils
public static String htmlEscapeHex(String input)
{
    return htmlEscapeHex(input, WebUtils.DEFAULT_CHARACTER_ENCODING);
}
org.springframework.web.util.HtmlUtils
public static String htmlUnescape(String input)
{
    return new HtmlCharacterEntityDecoder(characterEntityReferences, input).decode();
}
 HttpSessionMutexListener
 implements HttpSessionListener
org.springframework.web.util.HttpSessionMutexListener
@Override public void sessionCreated(HttpSessionEvent event)
{
    event.getSession().setAttribute(WebUtils.SESSION_MUTEX_ATTRIBUTE, new Mutex());
}
org.springframework.web.util.HttpSessionMutexListener
@Override public void sessionDestroyed(HttpSessionEvent event)
{
    event.getSession().removeAttribute(WebUtils.SESSION_MUTEX_ATTRIBUTE);
}
 IntrospectorCleanupListener
 implements ServletContextListener
org.springframework.web.util.IntrospectorCleanupListener
@Override public void contextDestroyed(ServletContextEvent event)
{
    CachedIntrospectionResults.clearClassLoader(Thread.currentThread().getContextClassLoader());
    Introspector.flushCaches();
}
org.springframework.web.util.IntrospectorCleanupListener
@Override public void contextInitialized(ServletContextEvent event)
{
    CachedIntrospectionResults.acceptClassLoader(Thread.currentThread().getContextClassLoader());
}
 JavaScriptUtils
org.springframework.web.util.JavaScriptUtils
public static String javaScriptEscape(String input)
{
    StringBuilder filtered = new StringBuilder(input.length());
    char prevChar = '\u0000';
    char c;
    for (int i = 0; i < input.length(); i++) {
        c = input.charAt(i);
        if (c == '"') {
            filtered.append("\\\"");
        } else if (c == '\'') {
            filtered.append("\\'");
        } else if (c == '\\') {
            filtered.append("\\\\");
        } else if (c == '/') {
            filtered.append("\\/");
        } else if (c == '\t') {
            filtered.append("\\t");
        } else if (c == '\n') {
            if (prevChar != '\r') {
                filtered.append("\\n");
            } 
        } else if (c == '\r') {
            filtered.append("\\n");
        } else if (c == '\f') {
            filtered.append("\\f");
        } else if (c == '\b') {
            filtered.append("\\b");
        } else if (c == '\013') {
            filtered.append("\\v");
        } else if (c == '<') {
            filtered.append("\\u003C");
        } else if (c == '>') {
            filtered.append("\\u003E");
        } else if (c == '\u2028') {
            filtered.append("\\u2028");
        } else if (c == '\u2029') {
            filtered.append("\\u2029");
        } else {
            filtered.append(c);
        }
        prevChar = c;
    }
    return filtered.toString();
}
 NestedServletException
 extends ServletException
org.springframework.web.util.NestedServletException
public NestedServletException NestedServletException(String msg)
{
    super(msg);
}
org.springframework.web.util.NestedServletException
public NestedServletException NestedServletException(@Nullable String msg, @Nullable Throwable cause)
{
    super(msg, cause);
}
org.springframework.web.util.NestedServletException
@Override @Nullable public String getMessage()
{
    return NestedExceptionUtils.buildMessage(super.getMessage(), getCause());
}
 OpaqueUriComponents
 extends UriComponents
org.springframework.web.util.OpaqueUriComponents
@Override protected void copyToUriComponentsBuilder(UriComponentsBuilder builder)
{
    if (getScheme() != null) {
        builder.scheme(getScheme());
    } 
    if (getSchemeSpecificPart() != null) {
        builder.schemeSpecificPart(getSchemeSpecificPart());
    } 
    if (getFragment() != null) {
        builder.fragment(getFragment());
    } 
}
org.springframework.web.util.OpaqueUriComponents
@Override public UriComponents encode(Charset charset)
{
    return this;
}
org.springframework.web.util.OpaqueUriComponents
@Override public boolean equals(@Nullable Object other)
{
    if (this == other) {
        return true;
    } 
    if (!(other instanceof OpaqueUriComponents)) {
        return false;
    } 
    OpaqueUriComponents otherComp = (OpaqueUriComponents)other;
    return (ObjectUtils.nullSafeEquals(getScheme(), otherComp.getScheme()) && ObjectUtils.nullSafeEquals(this.ssp, otherComp.ssp) && ObjectUtils.nullSafeEquals(getFragment(), otherComp.getFragment()));
}
org.springframework.web.util.OpaqueUriComponents
@Override @Nullable public String getHost()
{
    return null;
}
org.springframework.web.util.OpaqueUriComponents
@Override @Nullable public String getPath()
{
    return null;
}
org.springframework.web.util.OpaqueUriComponents
@Override public List<String> getPathSegments()
{
    return Collections.emptyList();
}
org.springframework.web.util.OpaqueUriComponents
@Override public int getPort()
{
    return -1;
}
org.springframework.web.util.OpaqueUriComponents
@Override @Nullable public String getQuery()
{
    return null;
}
org.springframework.web.util.OpaqueUriComponents
@Override public MultiValueMap<String, String> getQueryParams()
{
    return QUERY_PARAMS_NONE;
}
org.springframework.web.util.OpaqueUriComponents
@Override @Nullable public String getSchemeSpecificPart()
{
    return this.ssp;
}
org.springframework.web.util.OpaqueUriComponents
@Override @Nullable public String getUserInfo()
{
    return null;
}
org.springframework.web.util.OpaqueUriComponents
@Override public UriComponents normalize()
{
    return this;
}
org.springframework.web.util.OpaqueUriComponents
@Override public URI toUri()
{
    try {
        return new URI(getScheme(), this.ssp, getFragment());
    } catch (URISyntaxException ex) {
        throw new IllegalStateException("Could not create URI object: " + ex.getMessage(), ex);
    }
}
org.springframework.web.util.OpaqueUriComponents
@Override public String toUriString()
{
    StringBuilder uriBuilder = new StringBuilder();
    if (getScheme() != null) {
        uriBuilder.append(getScheme());
        uriBuilder.append(':');
    } 
    if (this.ssp != null) {
        uriBuilder.append(this.ssp);
    } 
    if (getFragment() != null) {
        uriBuilder.append('#');
        uriBuilder.append(getFragment());
    } 
    return uriBuilder.toString();
}
 ServletContextPropertyUtils
org.springframework.web.util.ServletContextPropertyUtils
public static String resolvePlaceholders(String text, ServletContext servletContext)
{
    return resolvePlaceholders(text, servletContext, false);
}
org.springframework.web.util.ServletContextPropertyUtils
public static String resolvePlaceholders(String text, ServletContext servletContext, boolean ignoreUnresolvablePlaceholders)
{
    PropertyPlaceholderHelper helper = (ignoreUnresolvablePlaceholders ? nonStrictHelper : strictHelper);
    return helper.replacePlaceholders(text, new ServletContextPlaceholderResolver(text, servletContext));
}
 TagUtils
org.springframework.web.util.TagUtils
public static final String SCOPE_APPLICATION
org.springframework.web.util.TagUtils
public static final String SCOPE_PAGE
org.springframework.web.util.TagUtils
public static final String SCOPE_REQUEST
org.springframework.web.util.TagUtils
public static final String SCOPE_SESSION
org.springframework.web.util.TagUtils
public static int getScope(String scope)
{
    Assert.notNull(scope, "Scope to search for cannot be null");
    if (scope.equals(SCOPE_REQUEST)) {
        return PageContext.REQUEST_SCOPE;
    } else if (scope.equals(SCOPE_SESSION)) {
        return PageContext.SESSION_SCOPE;
    } else if (scope.equals(SCOPE_APPLICATION)) {
        return PageContext.APPLICATION_SCOPE;
    } else {
        return PageContext.PAGE_SCOPE;
    }
}
 UriBuilder
 UriBuilderFactory
inherit classes
  • UriTemplateHandler
 UriComponents
 implements Serializable
org.springframework.web.util.UriComponents
protected UriComponents UriComponents(@Nullable String scheme, @Nullable String fragment)
{
    this.scheme = scheme;
    this.fragment = fragment;
}
 UriTemplateVariables
org.springframework.web.util.UriComponents
protected abstract void copyToUriComponentsBuilder(UriComponentsBuilder builder)
org.springframework.web.util.UriComponents
public final UriComponents encode()
{
    return encode(StandardCharsets.UTF_8);
}
org.springframework.web.util.UriComponents
public abstract UriComponents encode(Charset charset)
org.springframework.web.util.UriComponents
public final UriComponents expand(Map<String, ?> uriVariables)
{
    Assert.notNull(uriVariables, "'uriVariables' must not be null");
    return expandInternal(new MapTemplateVariables(uriVariables));
}
org.springframework.web.util.UriComponents
public final UriComponents expand(Object... uriVariableValues)
{
    Assert.notNull(uriVariableValues, "'uriVariableValues' must not be null");
    return expandInternal(new VarArgsTemplateVariables(uriVariableValues));
}
org.springframework.web.util.UriComponents
public final UriComponents expand(UriTemplateVariables uriVariables)
{
    Assert.notNull(uriVariables, "'uriVariables' must not be null");
    return expandInternal(uriVariables);
}
org.springframework.web.util.UriComponents
@Nullable public final String getFragment()
{
    return this.fragment;
}
org.springframework.web.util.UriComponents
@Nullable public abstract String getHost()
org.springframework.web.util.UriComponents
@Nullable public abstract String getPath()
org.springframework.web.util.UriComponents
public abstract List<String> getPathSegments()
org.springframework.web.util.UriComponents
public abstract int getPort()
org.springframework.web.util.UriComponents
@Nullable public abstract String getQuery()
org.springframework.web.util.UriComponents
public abstract MultiValueMap<String, String> getQueryParams()
org.springframework.web.util.UriComponents
@Nullable public final String getScheme()
{
    return this.scheme;
}
org.springframework.web.util.UriComponents
@Nullable public abstract String getSchemeSpecificPart()
org.springframework.web.util.UriComponents
@Nullable public abstract String getUserInfo()
org.springframework.web.util.UriComponents
public abstract UriComponents normalize()
org.springframework.web.util.UriComponents
@Override public final String toString()
{
    return toUriString();
}
org.springframework.web.util.UriComponents
public abstract URI toUri()
org.springframework.web.util.UriComponents
public abstract String toUriString()
 UriComponentsBuilder
 implements UriBuilder, Cloneable
org.springframework.web.util.UriComponentsBuilder
protected UriComponentsBuilder UriComponentsBuilder()
{
    this.pathBuilder = new CompositePathComponentBuilder();
}
org.springframework.web.util.UriComponentsBuilder
public UriComponents build()
{
    return build(false);
}
org.springframework.web.util.UriComponentsBuilder
public UriComponents build(boolean encoded)
{
    return buildInternal(encoded ? EncodingHint.FULLY_ENCODED : this.encodeTemplate ? EncodingHint.ENCODE_TEMPLATE : EncodingHint.NONE);
}
org.springframework.web.util.UriComponentsBuilder
@Override public URI build(Object... uriVariables)
{
    return buildInternal(EncodingHint.ENCODE_TEMPLATE).expand(uriVariables).toUri();
}
org.springframework.web.util.UriComponentsBuilder
@Override public URI build(Map<String, ?> uriVariables)
{
    return buildInternal(EncodingHint.ENCODE_TEMPLATE).expand(uriVariables).toUri();
}
org.springframework.web.util.UriComponentsBuilder
public UriComponents buildAndExpand(Map<String, ?> uriVariables)
{
    return build().expand(uriVariables);
}
org.springframework.web.util.UriComponentsBuilder
public UriComponents buildAndExpand(Object... uriVariableValues)
{
    return build().expand(uriVariableValues);
}
org.springframework.web.util.UriComponentsBuilder
@Override public Object clone()
{
    return cloneBuilder();
}
org.springframework.web.util.UriComponentsBuilder
public UriComponentsBuilder cloneBuilder()
{
    return new UriComponentsBuilder(this);
}
org.springframework.web.util.UriComponentsBuilder
public final UriComponentsBuilder encode()
{
    return encode(StandardCharsets.UTF_8);
}
org.springframework.web.util.UriComponentsBuilder
public UriComponentsBuilder encode(Charset charset)
{
    this.encodeTemplate = true;
    this.charset = charset;
    return this;
}
org.springframework.web.util.UriComponentsBuilder
@Override public UriComponentsBuilder fragment(@Nullable String fragment)
{
    if (fragment != null) {
        Assert.hasLength(fragment, "Fragment must not be empty");
        this.fragment = fragment;
    } else {
        this.fragment = null;
    }
    return this;
}
org.springframework.web.util.UriComponentsBuilder
public static UriComponentsBuilder fromHttpRequest(HttpRequest request)
{
    return fromUri(request.getURI()).adaptFromForwardedHeaders(request.getHeaders());
}
org.springframework.web.util.UriComponentsBuilder
public static UriComponentsBuilder fromPath(String path)
{
    UriComponentsBuilder builder = new UriComponentsBuilder();
    builder.path(path);
    return builder;
}
org.springframework.web.util.UriComponentsBuilder
public static UriComponentsBuilder fromUri(URI uri)
{
    UriComponentsBuilder builder = new UriComponentsBuilder();
    builder.uri(uri);
    return builder;
}
org.springframework.web.util.UriComponentsBuilder
@Override public UriComponentsBuilder host(@Nullable String host)
{
    this.host = host;
    resetSchemeSpecificPart();
    return this;
}
org.springframework.web.util.UriComponentsBuilder
public static UriComponentsBuilder newInstance()
{
    return new UriComponentsBuilder();
}
org.springframework.web.util.UriComponentsBuilder
@Override public UriComponentsBuilder path(String path)
{
    this.pathBuilder.addPath(path);
    resetSchemeSpecificPart();
    return this;
}
org.springframework.web.util.UriComponentsBuilder
@Override public UriComponentsBuilder pathSegment(String... pathSegments)
{
    this.pathBuilder.addPathSegments(pathSegments);
    resetSchemeSpecificPart();
    return this;
}
org.springframework.web.util.UriComponentsBuilder
@Override public UriComponentsBuilder port(int port)
{
    Assert.isTrue(port >= -1, "Port must be >= -1");
    this.port = String.valueOf(port);
    resetSchemeSpecificPart();
    return this;
}
org.springframework.web.util.UriComponentsBuilder
@Override public UriComponentsBuilder port(@Nullable String port)
{
    this.port = port;
    resetSchemeSpecificPart();
    return this;
}
org.springframework.web.util.UriComponentsBuilder
@Override public UriComponentsBuilder queryParam(String name, Object... values)
{
    Assert.notNull(name, "Name must not be null");
    if (!ObjectUtils.isEmpty(values)) {
        for (Object value: values) {
            String valueAsString = (value != null ? value.toString() : null);
            this.queryParams.add(name, valueAsString);
        }
    } else {
        this.queryParams.add(name, null);
    }
    resetSchemeSpecificPart();
    return this;
}
org.springframework.web.util.UriComponentsBuilder
@Override public UriComponentsBuilder queryParam(String name, @Nullable Collection<?> values)
{
    return queryParam(name, values != null ? values.toArray() : EMPTY_VALUES);
}
org.springframework.web.util.UriComponentsBuilder
@Override public UriComponentsBuilder queryParams(@Nullable MultiValueMap<String, String> params)
{
    if (params != null) {
        this.queryParams.addAll(params);
    } 
    return this;
}
org.springframework.web.util.UriComponentsBuilder
@Override public UriComponentsBuilder replacePath(@Nullable String path)
{
    this.pathBuilder = new CompositePathComponentBuilder();
    if (path != null) {
        this.pathBuilder.addPath(path);
    } 
    resetSchemeSpecificPart();
    return this;
}
org.springframework.web.util.UriComponentsBuilder
@Override public UriComponentsBuilder replaceQuery(@Nullable String query)
{
    this.queryParams.clear();
    if (query != null) {
        query(query);
    } 
    resetSchemeSpecificPart();
    return this;
}
org.springframework.web.util.UriComponentsBuilder
@Override public UriComponentsBuilder replaceQueryParam(String name, Object... values)
{
    Assert.notNull(name, "Name must not be null");
    this.queryParams.remove(name);
    if (!ObjectUtils.isEmpty(values)) {
        queryParam(name, values);
    } 
    resetSchemeSpecificPart();
    return this;
}
org.springframework.web.util.UriComponentsBuilder
@Override public UriComponentsBuilder replaceQueryParam(String name, @Nullable Collection<?> values)
{
    return replaceQueryParam(name, values != null ? values.toArray() : EMPTY_VALUES);
}
org.springframework.web.util.UriComponentsBuilder
@Override public UriComponentsBuilder replaceQueryParams(@Nullable MultiValueMap<String, String> params)
{
    this.queryParams.clear();
    if (params != null) {
        this.queryParams.putAll(params);
    } 
    return this;
}
org.springframework.web.util.UriComponentsBuilder
@Override public UriComponentsBuilder scheme(@Nullable String scheme)
{
    this.scheme = scheme;
    return this;
}
org.springframework.web.util.UriComponentsBuilder
public UriComponentsBuilder schemeSpecificPart(String ssp)
{
    this.ssp = ssp;
    resetHierarchicalComponents();
    return this;
}
org.springframework.web.util.UriComponentsBuilder
public UriComponentsBuilder uriComponents(UriComponents uriComponents)
{
    Assert.notNull(uriComponents, "UriComponents must not be null");
    uriComponents.copyToUriComponentsBuilder(this);
    return this;
}
org.springframework.web.util.UriComponentsBuilder
public UriComponentsBuilder uriVariables(Map<String, Object> uriVariables)
{
    this.uriVariables.putAll(uriVariables);
    return this;
}
org.springframework.web.util.UriComponentsBuilder
@Override public UriComponentsBuilder userInfo(@Nullable String userInfo)
{
    this.userInfo = userInfo;
    resetSchemeSpecificPart();
    return this;
}
 UriTemplate
 implements Serializable
org.springframework.web.util.UriTemplate
public List<String> getVariableNames()
{
    return this.variableNames;
}
org.springframework.web.util.UriTemplate
public boolean matches(@Nullable String uri)
{
    if (uri == null) {
        return false;
    } 
    Matcher matcher = this.matchPattern.matcher(uri);
    return matcher.matches();
}
org.springframework.web.util.UriTemplate
@Override public String toString()
{
    return this.uriTemplate;
}
 UriTemplateHandler
 UriUtils
org.springframework.web.util.UriUtils
public static String decode(String source, String encoding)
{
    return StringUtils.uriDecode(source, Charset.forName(encoding));
}
org.springframework.web.util.UriUtils
public static String decode(String source, Charset charset)
{
    return StringUtils.uriDecode(source, charset);
}
org.springframework.web.util.UriUtils
public static String encode(String source, String encoding)
{
    return encode(source, encoding, HierarchicalUriComponents.Type.URI);
}
org.springframework.web.util.UriUtils
public static String encode(String source, Charset charset)
{
    return encode(source, charset, HierarchicalUriComponents.Type.URI);
}
org.springframework.web.util.UriUtils
public static String encodeAuthority(String authority, String encoding)
{
    return encode(authority, encoding, HierarchicalUriComponents.Type.AUTHORITY);
}
org.springframework.web.util.UriUtils
public static String encodeAuthority(String authority, Charset charset)
{
    return encode(authority, charset, HierarchicalUriComponents.Type.AUTHORITY);
}
org.springframework.web.util.UriUtils
public static String encodeFragment(String fragment, String encoding)
{
    return encode(fragment, encoding, HierarchicalUriComponents.Type.FRAGMENT);
}
org.springframework.web.util.UriUtils
public static String encodeFragment(String fragment, Charset charset)
{
    return encode(fragment, charset, HierarchicalUriComponents.Type.FRAGMENT);
}
org.springframework.web.util.UriUtils
public static String encodeHost(String host, String encoding)
{
    return encode(host, encoding, HierarchicalUriComponents.Type.HOST_IPV4);
}
org.springframework.web.util.UriUtils
public static String encodeHost(String host, Charset charset)
{
    return encode(host, charset, HierarchicalUriComponents.Type.HOST_IPV4);
}
org.springframework.web.util.UriUtils
public static String encodePath(String path, String encoding)
{
    return encode(path, encoding, HierarchicalUriComponents.Type.PATH);
}
org.springframework.web.util.UriUtils
public static String encodePath(String path, Charset charset)
{
    return encode(path, charset, HierarchicalUriComponents.Type.PATH);
}
org.springframework.web.util.UriUtils
public static String encodePathSegment(String segment, String encoding)
{
    return encode(segment, encoding, HierarchicalUriComponents.Type.PATH_SEGMENT);
}
org.springframework.web.util.UriUtils
public static String encodePathSegment(String segment, Charset charset)
{
    return encode(segment, charset, HierarchicalUriComponents.Type.PATH_SEGMENT);
}
org.springframework.web.util.UriUtils
public static String encodePort(String port, String encoding)
{
    return encode(port, encoding, HierarchicalUriComponents.Type.PORT);
}
org.springframework.web.util.UriUtils
public static String encodePort(String port, Charset charset)
{
    return encode(port, charset, HierarchicalUriComponents.Type.PORT);
}
org.springframework.web.util.UriUtils
public static String encodeQuery(String query, String encoding)
{
    return encode(query, encoding, HierarchicalUriComponents.Type.QUERY);
}
org.springframework.web.util.UriUtils
public static String encodeQuery(String query, Charset charset)
{
    return encode(query, charset, HierarchicalUriComponents.Type.QUERY);
}
org.springframework.web.util.UriUtils
public static String encodeQueryParam(String queryParam, String encoding)
{
    return encode(queryParam, encoding, HierarchicalUriComponents.Type.QUERY_PARAM);
}
org.springframework.web.util.UriUtils
public static String encodeQueryParam(String queryParam, Charset charset)
{
    return encode(queryParam, charset, HierarchicalUriComponents.Type.QUERY_PARAM);
}
org.springframework.web.util.UriUtils
public static String encodeScheme(String scheme, String encoding)
{
    return encode(scheme, encoding, HierarchicalUriComponents.Type.SCHEME);
}
org.springframework.web.util.UriUtils
public static String encodeScheme(String scheme, Charset charset)
{
    return encode(scheme, charset, HierarchicalUriComponents.Type.SCHEME);
}
org.springframework.web.util.UriUtils
public static Object[] encodeUriVariables(Object... uriVariables)
{
    return Arrays.stream(uriVariables).map(value -> {
        String stringValue = (value != null ? value.toString() : "");
        return encode(stringValue, StandardCharsets.UTF_8);
    }).toArray();
}
org.springframework.web.util.UriUtils
public static String encodeUserInfo(String userInfo, String encoding)
{
    return encode(userInfo, encoding, HierarchicalUriComponents.Type.USER_INFO);
}
org.springframework.web.util.UriUtils
public static String encodeUserInfo(String userInfo, Charset charset)
{
    return encode(userInfo, charset, HierarchicalUriComponents.Type.USER_INFO);
}
org.springframework.web.util.UriUtils
@Nullable public static String extractFileExtension(String path)
{
    int end = path.indexOf('?');
    int fragmentIndex = path.indexOf('#');
    if (fragmentIndex != -1 && (end == -1 || fragmentIndex < end)) {
        end = fragmentIndex;
    } 
    if (end == -1) {
        end = path.length();
    } 
    int begin = path.lastIndexOf('/', end) + 1;
    int paramIndex = path.indexOf(';', begin);
    end = (paramIndex != -1 && paramIndex < end ? paramIndex : end);
    int extIndex = path.lastIndexOf('.', end);
    if (extIndex != -1 && extIndex > begin) {
        return path.substring(extIndex + 1, end);
    } 
    return null;
}
 UrlPathHelper
org.springframework.web.util.UrlPathHelper
public MultiValueMap<String, String> decodeMatrixVariables(HttpServletRequest request, MultiValueMap<String, String> vars)
{
    if (this.urlDecode) {
        return vars;
    } else {
        MultiValueMap<String, String> decodedVars = new LinkedMultiValueMap<>(vars.size());
        vars.forEach((key, values) -> {
            for (String value: values) {
                decodedVars.add(key, decodeInternal(request, value));
            }
        });
        return decodedVars;
    }
}
org.springframework.web.util.UrlPathHelper
public Map<String, String> decodePathVariables(HttpServletRequest request, Map<String, String> vars)
{
    if (this.urlDecode) {
        return vars;
    } else {
        Map<String, String> decodedVars = new LinkedHashMap<>(vars.size());
        vars.forEach((key, value) -> decodedVars.put(key, decodeInternal(request, value)));
        return decodedVars;
    }
}
org.springframework.web.util.UrlPathHelper
public String decodeRequestString(HttpServletRequest request, String source)
{
    if (this.urlDecode) {
        return decodeInternal(request, source);
    } 
    return source;
}
org.springframework.web.util.UrlPathHelper
protected String determineEncoding(HttpServletRequest request)
{
    String enc = request.getCharacterEncoding();
    if (enc == null) {
        enc = getDefaultEncoding();
    } 
    return enc;
}
org.springframework.web.util.UrlPathHelper
public String getContextPath(HttpServletRequest request)
{
    String contextPath = (String)request.getAttribute(WebUtils.INCLUDE_CONTEXT_PATH_ATTRIBUTE);
    if (contextPath == null) {
        contextPath = request.getContextPath();
    } 
    if ("/".equals(contextPath)) {
        contextPath = "";
    } 
    return decodeRequestString(request, contextPath);
}
org.springframework.web.util.UrlPathHelper
protected String getDefaultEncoding()
{
    return this.defaultEncoding;
}
org.springframework.web.util.UrlPathHelper
public String getLookupPathForRequest(HttpServletRequest request)
{
    if (this.alwaysUseFullPath) {
        return getPathWithinApplication(request);
    } 
    String rest = getPathWithinServletMapping(request);
    if (!"".equals(rest)) {
        return rest;
    } else {
        return getPathWithinApplication(request);
    }
}
org.springframework.web.util.UrlPathHelper
public String getLookupPathForRequest(HttpServletRequest request, @Nullable String lookupPathAttributeName)
{
    if (lookupPathAttributeName != null) {
        String result = (String)request.getAttribute(lookupPathAttributeName);
        if (result != null) {
            return result;
        } 
    } 
    return getLookupPathForRequest(request);
}
org.springframework.web.util.UrlPathHelper
public String getOriginatingContextPath(HttpServletRequest request)
{
    String contextPath = (String)request.getAttribute(WebUtils.FORWARD_CONTEXT_PATH_ATTRIBUTE);
    if (contextPath == null) {
        contextPath = request.getContextPath();
    } 
    return decodeRequestString(request, contextPath);
}
org.springframework.web.util.UrlPathHelper
public String getOriginatingRequestUri(HttpServletRequest request)
{
    String uri = (String)request.getAttribute(WEBSPHERE_URI_ATTRIBUTE);
    if (uri == null) {
        uri = (String)request.getAttribute(WebUtils.FORWARD_REQUEST_URI_ATTRIBUTE);
        if (uri == null) {
            uri = request.getRequestURI();
        } 
    } 
    return decodeAndCleanUriString(request, uri);
}
org.springframework.web.util.UrlPathHelper
public String getOriginatingServletPath(HttpServletRequest request)
{
    String servletPath = (String)request.getAttribute(WebUtils.FORWARD_SERVLET_PATH_ATTRIBUTE);
    if (servletPath == null) {
        servletPath = request.getServletPath();
    } 
    return servletPath;
}
org.springframework.web.util.UrlPathHelper
public String getRequestUri(HttpServletRequest request)
{
    String uri = (String)request.getAttribute(WebUtils.INCLUDE_REQUEST_URI_ATTRIBUTE);
    if (uri == null) {
        uri = request.getRequestURI();
    } 
    return decodeAndCleanUriString(request, uri);
}
org.springframework.web.util.UrlPathHelper
public String getServletPath(HttpServletRequest request)
{
    String servletPath = (String)request.getAttribute(WebUtils.INCLUDE_SERVLET_PATH_ATTRIBUTE);
    if (servletPath == null) {
        servletPath = request.getServletPath();
    } 
    if (servletPath.length() > 1 && servletPath.endsWith("/") && shouldRemoveTrailingServletPathSlash(request)) {
        servletPath = servletPath.substring(0, servletPath.length() - 1);
    } 
    return servletPath;
}
org.springframework.web.util.UrlPathHelper
public boolean isUrlDecode()
{
    return this.urlDecode;
}
org.springframework.web.util.UrlPathHelper
public String removeSemicolonContent(String requestUri)
{
    return (this.removeSemicolonContent ? removeSemicolonContentInternal(requestUri) : removeJsessionid(requestUri));
}
org.springframework.web.util.UrlPathHelper
public void setAlwaysUseFullPath(boolean alwaysUseFullPath)
{
    this.alwaysUseFullPath = alwaysUseFullPath;
}
org.springframework.web.util.UrlPathHelper
public void setDefaultEncoding(String defaultEncoding)
{
    this.defaultEncoding = defaultEncoding;
}
org.springframework.web.util.UrlPathHelper
public void setRemoveSemicolonContent(boolean removeSemicolonContent)
{
    this.removeSemicolonContent = removeSemicolonContent;
}
org.springframework.web.util.UrlPathHelper
public void setUrlDecode(boolean urlDecode)
{
    this.urlDecode = urlDecode;
}
org.springframework.web.util.UrlPathHelper
public boolean shouldRemoveSemicolonContent()
{
    return this.removeSemicolonContent;
}
org.springframework.web.util.UrlPathHelper
@Nullable volatile static Boolean websphereComplianceFlag
 WebAppRootListener
 implements ServletContextListener
org.springframework.web.util.WebAppRootListener
@Override public void contextDestroyed(ServletContextEvent event)
{
    WebUtils.removeWebAppRootSystemProperty(event.getServletContext());
}
org.springframework.web.util.WebAppRootListener
@Override public void contextInitialized(ServletContextEvent event)
{
    WebUtils.setWebAppRootSystemProperty(event.getServletContext());
}
 WebUtils
org.springframework.web.util.WebUtils
public static final String CONTENT_TYPE_CHARSET_PREFIX
org.springframework.web.util.WebUtils
public static final String DEFAULT_CHARACTER_ENCODING
org.springframework.web.util.WebUtils
public static final String DEFAULT_WEB_APP_ROOT_KEY
org.springframework.web.util.WebUtils
public static final String ERROR_EXCEPTION_ATTRIBUTE
org.springframework.web.util.WebUtils
public static final String ERROR_EXCEPTION_TYPE_ATTRIBUTE
org.springframework.web.util.WebUtils
public static final String ERROR_MESSAGE_ATTRIBUTE
org.springframework.web.util.WebUtils
public static final String ERROR_REQUEST_URI_ATTRIBUTE
org.springframework.web.util.WebUtils
public static final String ERROR_SERVLET_NAME_ATTRIBUTE
org.springframework.web.util.WebUtils
public static final String ERROR_STATUS_CODE_ATTRIBUTE
org.springframework.web.util.WebUtils
public static final String FORWARD_CONTEXT_PATH_ATTRIBUTE
org.springframework.web.util.WebUtils
public static final String FORWARD_PATH_INFO_ATTRIBUTE
org.springframework.web.util.WebUtils
public static final String FORWARD_QUERY_STRING_ATTRIBUTE
org.springframework.web.util.WebUtils
public static final String FORWARD_REQUEST_URI_ATTRIBUTE
org.springframework.web.util.WebUtils
public static final String FORWARD_SERVLET_PATH_ATTRIBUTE
org.springframework.web.util.WebUtils
public static final String HTML_ESCAPE_CONTEXT_PARAM
org.springframework.web.util.WebUtils
public static final String INCLUDE_CONTEXT_PATH_ATTRIBUTE
org.springframework.web.util.WebUtils
public static final String INCLUDE_PATH_INFO_ATTRIBUTE
org.springframework.web.util.WebUtils
public static final String INCLUDE_QUERY_STRING_ATTRIBUTE
org.springframework.web.util.WebUtils
public static final String INCLUDE_REQUEST_URI_ATTRIBUTE
org.springframework.web.util.WebUtils
public static final String INCLUDE_SERVLET_PATH_ATTRIBUTE
org.springframework.web.util.WebUtils
public static final String RESPONSE_ENCODED_HTML_ESCAPE_CONTEXT_PARAM
org.springframework.web.util.WebUtils
public static final String SESSION_MUTEX_ATTRIBUTE
org.springframework.web.util.WebUtils
public static final String[] SUBMIT_IMAGE_SUFFIXES
org.springframework.web.util.WebUtils
public static final String TEMP_DIR_CONTEXT_ATTRIBUTE
org.springframework.web.util.WebUtils
public static final String WEB_APP_ROOT_KEY_PARAM
org.springframework.web.util.WebUtils
@Nullable public static String findParameterValue(ServletRequest request, String name)
{
    return findParameterValue(request.getParameterMap(), name);
}
org.springframework.web.util.WebUtils
@Nullable public static String findParameterValue(Map<String, ?> parameters, String name)
{
    Object value = parameters.get(name);
    if (value instanceof String[]) {
        String[] values = (String[])value;
        return (values.length > 0 ? values[0] : null);
    } else if (value != null) {
        return value.toString();
    } 
    String prefix = name + "_";
    for (String paramName: parameters.keySet()) {
        if (paramName.startsWith(prefix)) {
            for (String suffix: SUBMIT_IMAGE_SUFFIXES) {
                if (paramName.endsWith(suffix)) {
                    return paramName.substring(prefix.length(), paramName.length() - suffix.length());
                } 
            }
            return paramName.substring(prefix.length());
        } 
    }
    return null;
}
org.springframework.web.util.WebUtils
@Nullable public static Cookie getCookie(HttpServletRequest request, String name)
{
    Assert.notNull(request, "Request must not be null");
    Cookie[] cookies = request.getCookies();
    if (cookies != null) {
        for (Cookie cookie: cookies) {
            if (name.equals(cookie.getName())) {
                return cookie;
            } 
        }
    } 
    return null;
}
org.springframework.web.util.WebUtils
@Nullable public static Boolean getDefaultHtmlEscape(@Nullable ServletContext servletContext)
{
    if (servletContext == null) {
        return null;
    } 
    String param = servletContext.getInitParameter(HTML_ESCAPE_CONTEXT_PARAM);
    return (StringUtils.hasText(param) ? Boolean.valueOf(param) : null);
}
org.springframework.web.util.WebUtils
<T>@SuppressWarnings("unchecked") @Nullable public static T getNativeRequest(ServletRequest request, @Nullable Class<T> requiredType)
{
    if (requiredType != null) {
        if (requiredType.isInstance(request)) {
            return (T)request;
        } else if (request instanceof ServletRequestWrapper) {
            return getNativeRequest(((ServletRequestWrapper)request).getRequest(), requiredType);
        } 
    } 
    return null;
}
org.springframework.web.util.WebUtils
<T>@SuppressWarnings("unchecked") @Nullable public static T getNativeResponse(ServletResponse response, @Nullable Class<T> requiredType)
{
    if (requiredType != null) {
        if (requiredType.isInstance(response)) {
            return (T)response;
        } else if (response instanceof ServletResponseWrapper) {
            return getNativeResponse(((ServletResponseWrapper)response).getResponse(), requiredType);
        } 
    } 
    return null;
}
org.springframework.web.util.WebUtils
public static String getRealPath(ServletContext servletContext, String path)
{
    Assert.notNull(servletContext, "ServletContext must not be null");
    if (!path.startsWith("/")) {
        path = "/" + path;
    } 
    String realPath = servletContext.getRealPath(path);
    if (realPath == null) {
        throw new FileNotFoundException("ServletContext resource [" + path + "] cannot be resolved to absolute file path - " + "web application archive not expanded?");
    } 
    return realPath;
}
org.springframework.web.util.WebUtils
public static Object getRequiredSessionAttribute(HttpServletRequest request, String name)
{
    Object attr = getSessionAttribute(request, name);
    if (attr == null) {
        throw new IllegalStateException("No session attribute '" + name + "' found");
    } 
    return attr;
}
org.springframework.web.util.WebUtils
@Nullable public static Boolean getResponseEncodedHtmlEscape(@Nullable ServletContext servletContext)
{
    if (servletContext == null) {
        return null;
    } 
    String param = servletContext.getInitParameter(RESPONSE_ENCODED_HTML_ESCAPE_CONTEXT_PARAM);
    return (StringUtils.hasText(param) ? Boolean.valueOf(param) : null);
}
org.springframework.web.util.WebUtils
@Nullable public static Object getSessionAttribute(HttpServletRequest request, String name)
{
    Assert.notNull(request, "Request must not be null");
    HttpSession session = request.getSession(false);
    return (session != null ? session.getAttribute(name) : null);
}
org.springframework.web.util.WebUtils
@Nullable public static String getSessionId(HttpServletRequest request)
{
    Assert.notNull(request, "Request must not be null");
    HttpSession session = request.getSession(false);
    return (session != null ? session.getId() : null);
}
org.springframework.web.util.WebUtils
public static Object getSessionMutex(HttpSession session)
{
    Assert.notNull(session, "Session must not be null");
    Object mutex = session.getAttribute(SESSION_MUTEX_ATTRIBUTE);
    if (mutex == null) {
        mutex = session;
    } 
    return mutex;
}
org.springframework.web.util.WebUtils
public static File getTempDir(ServletContext servletContext)
{
    Assert.notNull(servletContext, "ServletContext must not be null");
    return (File)servletContext.getAttribute(TEMP_DIR_CONTEXT_ATTRIBUTE);
}
org.springframework.web.util.WebUtils
public static boolean hasSubmitParameter(ServletRequest request, String name)
{
    Assert.notNull(request, "Request must not be null");
    if (request.getParameter(name) != null) {
        return true;
    } 
    for (String suffix: SUBMIT_IMAGE_SUFFIXES) {
        if (request.getParameter(name + suffix) != null) {
            return true;
        } 
    }
    return false;
}
org.springframework.web.util.WebUtils
public static boolean isIncludeRequest(ServletRequest request)
{
    return (request.getAttribute(INCLUDE_REQUEST_URI_ATTRIBUTE) != null);
}
org.springframework.web.util.WebUtils
public static boolean isSameOrigin(HttpRequest request)
{
    HttpHeaders headers = request.getHeaders();
    String origin = headers.getOrigin();
    if (origin == null) {
        return true;
    } 
    String scheme;
    String host;
    int port;
    if (request instanceof ServletServerHttpRequest) {
        HttpServletRequest servletRequest = ((ServletServerHttpRequest)request).getServletRequest();
        scheme = servletRequest.getScheme();
        host = servletRequest.getServerName();
        port = servletRequest.getServerPort();
    } else {
        URI uri = request.getURI();
        scheme = uri.getScheme();
        host = uri.getHost();
        port = uri.getPort();
    }
    UriComponents originUrl = UriComponentsBuilder.fromOriginHeader(origin).build();
    return (ObjectUtils.nullSafeEquals(scheme, originUrl.getScheme()) && ObjectUtils.nullSafeEquals(host, originUrl.getHost()) && getPort(scheme, port) == getPort(originUrl.getScheme(), originUrl.getPort()));
}
org.springframework.web.util.WebUtils
public static void setWebAppRootSystemProperty(ServletContext servletContext)
{
    Assert.notNull(servletContext, "ServletContext must not be null");
    String root = servletContext.getRealPath("/");
    if (root == null) {
        throw new IllegalStateException("Cannot set web app root system property when WAR file is not expanded");
    } 
    String param = servletContext.getInitParameter(WEB_APP_ROOT_KEY_PARAM);
    String key = (param != null ? param : DEFAULT_WEB_APP_ROOT_KEY);
    String oldValue = System.getProperty(key);
    if (oldValue != null && !StringUtils.pathEquals(oldValue, root)) {
        throw new IllegalStateException("Web app root system property already set to different value: '" + key + "' = [" + oldValue + "] instead of [" + root + "] - " + "Choose unique values for the 'webAppRootKey' context-param in your web.xml files!");
    } 
    System.setProperty(key, root);
    servletContext.log("Set web app root system property: '" + key + "' = [" + root + "]");
}
 CaptureTheRestPathElement
 extends PathElement
org.springframework.web.util.pattern.CaptureTheRestPathElement
@Override public int getCaptureCount()
{
    return 1;
}
org.springframework.web.util.pattern.CaptureTheRestPathElement
@Override public char[] getChars()
{
    return ("/{*" + this.variableName + "}").toCharArray();
}
org.springframework.web.util.pattern.CaptureTheRestPathElement
@Override public int getNormalizedLength()
{
    return 1;
}
org.springframework.web.util.pattern.CaptureTheRestPathElement
@Override public int getWildcardCount()
{
    return 0;
}
org.springframework.web.util.pattern.CaptureTheRestPathElement
@Override public boolean matches(int pathIndex, MatchingContext matchingContext)
{
    if (pathIndex < matchingContext.pathLength && !matchingContext.isSeparator(pathIndex)) {
        return false;
    } 
    if (matchingContext.determineRemainingPath) {
        matchingContext.remainingPathIndex = matchingContext.pathLength;
    } 
    if (matchingContext.extractingVariables) {
        MultiValueMap<String, String> parametersCollector = null;
        for (int i = pathIndex; i < matchingContext.pathLength; i++) {
            Element element = matchingContext.pathElements.get(i);
            if (element instanceof PathSegment) {
                MultiValueMap<String, String> parameters = ((PathSegment)element).parameters();
                if (!parameters.isEmpty()) {
                    if (parametersCollector == null) {
                        parametersCollector = new LinkedMultiValueMap<>();
                    } 
                    parametersCollector.addAll(parameters);
                } 
            } 
        }
        matchingContext.set(this.variableName, pathToString(pathIndex, matchingContext.pathElements), parametersCollector == null ? NO_PARAMETERS : parametersCollector);
    } 
    return true;
}
org.springframework.web.util.pattern.CaptureTheRestPathElement
@Override public String toString()
{
    return "CaptureTheRest(/{*" + this.variableName + "})";
}
 CaptureVariablePathElement
 extends PathElement
org.springframework.web.util.pattern.CaptureVariablePathElement
@Override public int getCaptureCount()
{
    return 1;
}
org.springframework.web.util.pattern.CaptureVariablePathElement
@Override public char[] getChars()
{
    StringBuilder b = new StringBuilder();
    b.append("{");
    b.append(this.variableName);
    if (this.constraintPattern != null) {
        b.append(":").append(this.constraintPattern.pattern());
    } 
    b.append("}");
    return b.toString().toCharArray();
}
org.springframework.web.util.pattern.CaptureVariablePathElement
@Override public int getNormalizedLength()
{
    return 1;
}
org.springframework.web.util.pattern.CaptureVariablePathElement
@Override public int getScore()
{
    return CAPTURE_VARIABLE_WEIGHT;
}
org.springframework.web.util.pattern.CaptureVariablePathElement
public String getVariableName()
{
    return this.variableName;
}
org.springframework.web.util.pattern.CaptureVariablePathElement
@Override public int getWildcardCount()
{
    return 0;
}
org.springframework.web.util.pattern.CaptureVariablePathElement
@Override public String toString()
{
    return "CaptureVariable({" + this.variableName + (this.constraintPattern != null ? ":" + this.constraintPattern.pattern() : "") + "})";
}
 InternalPathPatternParser
org.springframework.web.util.pattern.InternalPathPatternParser
public PathPattern parse(String pathPattern)
{
    Assert.notNull(pathPattern, "Path pattern must not be null");
    this.pathPatternData = pathPattern.toCharArray();
    this.pathPatternLength = this.pathPatternData.length;
    this.headPE = null;
    this.currentPE = null;
    this.capturedVariableNames = null;
    this.pathElementStart = -1;
    this.pos = 0;
    resetPathElementState();
    while (this.pos < this.pathPatternLength) {
        char ch = this.pathPatternData[this.pos];
        char separator = this.parser.getPathOptions().separator();
        if (ch == separator) {
            if (this.pathElementStart != -1) {
                pushPathElement(createPathElement());
            } 
            if (peekDoubleWildcard()) {
                pushPathElement(new WildcardTheRestPathElement(this.pos, separator));
                this.pos += 2;
            } else {
                pushPathElement(new SeparatorPathElement(this.pos, separator));
            }
        } else {
            if (this.pathElementStart == -1) {
                this.pathElementStart = this.pos;
            } 
            if (ch == '?') {
                this.singleCharWildcardCount++;
            } else if (ch == '{') {
                if (this.insideVariableCapture) {
                    throw new PatternParseException(this.pos, this.pathPatternData, PatternMessage.ILLEGAL_NESTED_CAPTURE);
                } 
                this.insideVariableCapture = true;
                this.variableCaptureStart = this.pos;
            } else if (ch == '}') {
                if (!this.insideVariableCapture) {
                    throw new PatternParseException(this.pos, this.pathPatternData, PatternMessage.MISSING_OPEN_CAPTURE);
                } 
                this.insideVariableCapture = false;
                if (this.isCaptureTheRestVariable && (this.pos + 1) < this.pathPatternLength) {
                    throw new PatternParseException(this.pos + 1, this.pathPatternData, PatternMessage.NO_MORE_DATA_EXPECTED_AFTER_CAPTURE_THE_REST);
                } 
                this.variableCaptureCount++;
            } else if (ch == ':') {
                if (this.insideVariableCapture && !this.isCaptureTheRestVariable) {
                    skipCaptureRegex();
                    this.insideVariableCapture = false;
                    this.variableCaptureCount++;
                } 
            } else if (ch == '*') {
                if (this.insideVariableCapture && this.variableCaptureStart == this.pos - 1) {
                    this.isCaptureTheRestVariable = true;
                } 
                this.wildcard = true;
            } 
            if (this.insideVariableCapture) {
                if ((this.variableCaptureStart + 1 + (this.isCaptureTheRestVariable ? 1 : 0)) == this.pos && !Character.isJavaIdentifierStart(ch)) {
                    throw new PatternParseException(this.pos, this.pathPatternData, PatternMessage.ILLEGAL_CHARACTER_AT_START_OF_CAPTURE_DESCRIPTOR, Character.toString(ch));
                } else if ((this.pos > (this.variableCaptureStart + 1 + (this.isCaptureTheRestVariable ? 1 : 0)) && !Character.isJavaIdentifierPart(ch) && ch != '-')) {
                    throw new PatternParseException(this.pos, this.pathPatternData, PatternMessage.ILLEGAL_CHARACTER_IN_CAPTURE_DESCRIPTOR, Character.toString(ch));
                } 
            } 
        }
        this.pos++;
    }
    if (this.pathElementStart != -1) {
        pushPathElement(createPathElement());
    } 
    return new PathPattern(pathPattern, this.parser, this.headPE);
}
 LiteralPathElement
 extends PathElement
org.springframework.web.util.pattern.LiteralPathElement
@Override public char[] getChars()
{
    return this.text;
}
org.springframework.web.util.pattern.LiteralPathElement
@Override public int getNormalizedLength()
{
    return this.len;
}
org.springframework.web.util.pattern.LiteralPathElement
@Override public boolean matches(int pathIndex, MatchingContext matchingContext)
{
    if (pathIndex >= matchingContext.pathLength) {
        return false;
    } 
    Element element = matchingContext.pathElements.get(pathIndex);
    if (!(element instanceof PathContainer.PathSegment)) {
        return false;
    } 
    String value = ((PathSegment)element).valueToMatch();
    if (value.length() != this.len) {
        return false;
    } 
    char[] data = ((PathContainer.PathSegment)element).valueToMatchAsChars();
    if (this.caseSensitive) {
        for (int i = 0; i < this.len; i++) {
            if (data[i] != this.text[i]) {
                return false;
            } 
        }
    } else {
        for (int i = 0; i < this.len; i++) {
            if (Character.toLowerCase(data[i]) != this.text[i]) {
                return false;
            } 
        }
    }
    pathIndex++;
    if (isNoMorePattern()) {
        if (matchingContext.determineRemainingPath) {
            matchingContext.remainingPathIndex = pathIndex;
            return true;
        } else {
            if (pathIndex == matchingContext.pathLength) {
                return true;
            } else {
                return (matchingContext.isMatchOptionalTrailingSeparator() && (pathIndex + 1) == matchingContext.pathLength && matchingContext.isSeparator(pathIndex));
            }
        }
    } else {
        return (this.next != null && this.next.matches(pathIndex, matchingContext));
    }
}
org.springframework.web.util.pattern.LiteralPathElement
@Override public String toString()
{
    return "Literal(" + String.valueOf(this.text) + ")";
}
 PathElement
org.springframework.web.util.pattern.PathElement
protected static final int CAPTURE_VARIABLE_WEIGHT
org.springframework.web.util.pattern.PathElement
protected static final MultiValueMap<String, String> NO_PARAMETERS
org.springframework.web.util.pattern.PathElement
protected static final int WILDCARD_WEIGHT
org.springframework.web.util.pattern.PathElement
public int getCaptureCount()
{
    return 0;
}
org.springframework.web.util.pattern.PathElement
public abstract char[] getChars()
org.springframework.web.util.pattern.PathElement
public abstract int getNormalizedLength()
org.springframework.web.util.pattern.PathElement
public int getScore()
{
    return 0;
}
org.springframework.web.util.pattern.PathElement
public int getWildcardCount()
{
    return 0;
}
org.springframework.web.util.pattern.PathElement
protected final boolean isNoMorePattern()
{
    return this.next == null;
}
org.springframework.web.util.pattern.PathElement
public abstract boolean matches(int candidatePos, MatchingContext matchingContext)
org.springframework.web.util.pattern.PathElement
@Nullable protected PathElement next
org.springframework.web.util.pattern.PathElement
protected final int pos
org.springframework.web.util.pattern.PathElement
@Nullable protected PathElement prev
org.springframework.web.util.pattern.PathElement
protected final char separator
 PathPattern
 implements Comparable<PathPattern>
 PathMatchInfo
org.springframework.web.util.pattern.PathPattern.PathMatchInfo
public Map<String, MultiValueMap<String, String>> getMatrixVariables()
{
    return this.matrixVariables;
}
org.springframework.web.util.pattern.PathPattern.PathMatchInfo
public Map<String, String> getUriVariables()
{
    return this.uriVariables;
}
org.springframework.web.util.pattern.PathPattern.PathMatchInfo
@Override public String toString()
{
    return "PathMatchInfo[uriVariables=" + this.uriVariables + ", " + "matrixVariables=" + this.matrixVariables + "]";
}
 PathRemainingMatchInfo
org.springframework.web.util.pattern.PathPattern.PathRemainingMatchInfo
public Map<String, MultiValueMap<String, String>> getMatrixVariables()
{
    return this.pathMatchInfo.getMatrixVariables();
}
org.springframework.web.util.pattern.PathPattern.PathRemainingMatchInfo
public PathContainer getPathRemaining()
{
    return this.pathRemaining;
}
org.springframework.web.util.pattern.PathPattern.PathRemainingMatchInfo
public Map<String, String> getUriVariables()
{
    return this.pathMatchInfo.getUriVariables();
}
org.springframework.web.util.pattern.PathPattern
public static final Comparator<PathPattern> SPECIFICITY_COMPARATOR
org.springframework.web.util.pattern.PathPattern
public PathPattern combine(PathPattern pattern2string)
{
    if (!StringUtils.hasLength(this.patternString)) {
        if (!StringUtils.hasLength(pattern2string.patternString)) {
            return this.parser.parse("");
        } else {
            return pattern2string;
        }
    } else if (!StringUtils.hasLength(pattern2string.patternString)) {
        return this;
    } 
    if (!this.patternString.equals(pattern2string.patternString) && this.capturedVariableCount == 0 && matches(PathContainer.parsePath(pattern2string.patternString))) {
        return pattern2string;
    } 
    if (this.endsWithSeparatorWildcard) {
        return this.parser.parse(concat(this.patternString.substring(0, this.patternString.length() - 2), pattern2string.patternString));
    } 
    int starDotPos1 = this.patternString.indexOf("*.");
    if (this.capturedVariableCount != 0 || starDotPos1 == -1 || getSeparator() == '.') {
        return this.parser.parse(concat(this.patternString, pattern2string.patternString));
    } 
    String firstExtension = this.patternString.substring(starDotPos1 + 1);
    String p2string = pattern2string.patternString;
    int dotPos2 = p2string.indexOf('.');
    String file2 = (dotPos2 == -1 ? p2string : p2string.substring(0, dotPos2));
    String secondExtension = (dotPos2 == -1 ? "" : p2string.substring(dotPos2));
    boolean firstExtensionWild = (firstExtension.equals(".*") || firstExtension.equals(""));
    boolean secondExtensionWild = (secondExtension.equals(".*") || secondExtension.equals(""));
    if (!firstExtensionWild && !secondExtensionWild) {
        throw new IllegalArgumentException("Cannot combine patterns: " + this.patternString + " and " + pattern2string);
    } 
    return this.parser.parse(file2 + (firstExtensionWild ? secondExtension : firstExtension));
}
org.springframework.web.util.pattern.PathPattern
@Override public boolean equals(@Nullable Object other)
{
    if (!(other instanceof PathPattern)) {
        return false;
    } 
    PathPattern otherPattern = (PathPattern)other;
    return (this.patternString.equals(otherPattern.getPatternString()) && getSeparator() == otherPattern.getSeparator() && this.caseSensitive == otherPattern.caseSensitive);
}
org.springframework.web.util.pattern.PathPattern
public PathContainer extractPathWithinPattern(PathContainer path)
{
    List<Element> pathElements = path.elements();
    int pathElementsCount = pathElements.size();
    int startIndex = 0;
    PathElement elem = this.head;
    while (elem != null) {
        if (elem.getWildcardCount() != 0 || elem.getCaptureCount() != 0) {
            break;
        } 
        elem = elem.next;
        startIndex++;
    }
    if (elem == null) {
        return PathContainer.parsePath("");
    } 
    while (startIndex < pathElementsCount && (pathElements.get(startIndex) instanceof Separator)) {
        startIndex++;
    }
    int endIndex = pathElements.size();
    while (endIndex > 0 && (pathElements.get(endIndex - 1) instanceof Separator)) {
        endIndex--;
    }
    boolean multipleAdjacentSeparators = false;
    for (int i = startIndex; i < (endIndex - 1); i++) {
        if ((pathElements.get(i) instanceof Separator) && (pathElements.get(i + 1) instanceof Separator)) {
            multipleAdjacentSeparators = true;
            break;
        } 
    }
    PathContainer resultPath = null;
    if (multipleAdjacentSeparators) {
        StringBuilder buf = new StringBuilder();
        int i = startIndex;
        while (i < endIndex) {
            Element e = pathElements.get(i++);
            buf.append(e.value());
            if (e instanceof Separator) {
                while (i < endIndex && (pathElements.get(i) instanceof Separator)) {
                    i++;
                }
            } 
        }
        resultPath = PathContainer.parsePath(buf.toString(), this.pathOptions);
    } else if (startIndex >= endIndex) {
        resultPath = PathContainer.parsePath("");
    } else {
        resultPath = path.subPath(startIndex, endIndex);
    }
    return resultPath;
}
org.springframework.web.util.pattern.PathPattern
public String getPatternString()
{
    return this.patternString;
}
org.springframework.web.util.pattern.PathPattern
public boolean hasPatternSyntax()
{
    return (this.score > 0 || this.patternString.indexOf('?') != -1);
}
org.springframework.web.util.pattern.PathPattern
@Override public int hashCode()
{
    return (this.patternString.hashCode() + getSeparator()) * 17 + (this.caseSensitive ? 1 : 0);
}
org.springframework.web.util.pattern.PathPattern
@Nullable public PathMatchInfo matchAndExtract(PathContainer pathContainer)
{
    if (this.head == null) {
        return (hasLength(pathContainer) && !(this.matchOptionalTrailingSeparator && pathContainerIsJustSeparator(pathContainer)) ? null : PathMatchInfo.EMPTY);
    } else if (!hasLength(pathContainer)) {
        if (this.head instanceof WildcardTheRestPathElement || this.head instanceof CaptureTheRestPathElement) {
            pathContainer = EMPTY_PATH;
        } else {
            return null;
        }
    } 
    MatchingContext matchingContext = new MatchingContext(pathContainer, true);
    return this.head.matches(0, matchingContext) ? matchingContext.getPathMatchResult() : null;
}
org.springframework.web.util.pattern.PathPattern
@Nullable public PathRemainingMatchInfo matchStartOfPath(PathContainer pathContainer)
{
    if (this.head == null) {
        return new PathRemainingMatchInfo(pathContainer);
    } else if (!hasLength(pathContainer)) {
        return null;
    } 
    MatchingContext matchingContext = new MatchingContext(pathContainer, true);
    matchingContext.setMatchAllowExtraPath();
    boolean matches = this.head.matches(0, matchingContext);
    if (!matches) {
        return null;
    } else {
        PathRemainingMatchInfo info;
        if (matchingContext.remainingPathIndex == pathContainer.elements().size()) {
            info = new PathRemainingMatchInfo(EMPTY_PATH, matchingContext.getPathMatchResult());
        } else {
            info = new PathRemainingMatchInfo(pathContainer.subPath(matchingContext.remainingPathIndex), matchingContext.getPathMatchResult());
        }
        return info;
    }
}
org.springframework.web.util.pattern.PathPattern
public boolean matches(PathContainer pathContainer)
{
    if (this.head == null) {
        return !hasLength(pathContainer) || (this.matchOptionalTrailingSeparator && pathContainerIsJustSeparator(pathContainer));
    } else if (!hasLength(pathContainer)) {
        if (this.head instanceof WildcardTheRestPathElement || this.head instanceof CaptureTheRestPathElement) {
            pathContainer = EMPTY_PATH;
        } else {
            return false;
        }
    } 
    MatchingContext matchingContext = new MatchingContext(pathContainer, false);
    return this.head.matches(0, matchingContext);
}
org.springframework.web.util.pattern.PathPattern
@Override public String toString()
{
    return this.patternString;
}
 PathPatternParser
org.springframework.web.util.pattern.PathPatternParser
public PathContainer.Options getPathOptions()
{
    return this.pathOptions;
}
org.springframework.web.util.pattern.PathPatternParser
public boolean isCaseSensitive()
{
    return this.caseSensitive;
}
org.springframework.web.util.pattern.PathPatternParser
public boolean isMatchOptionalTrailingSeparator()
{
    return this.matchOptionalTrailingSeparator;
}
org.springframework.web.util.pattern.PathPatternParser
public PathPattern parse(String pathPattern)
{
    return new InternalPathPatternParser(this).parse(pathPattern);
}
org.springframework.web.util.pattern.PathPatternParser
public void setCaseSensitive(boolean caseSensitive)
{
    this.caseSensitive = caseSensitive;
}
org.springframework.web.util.pattern.PathPatternParser
public void setMatchOptionalTrailingSeparator(boolean matchOptionalTrailingSeparator)
{
    this.matchOptionalTrailingSeparator = matchOptionalTrailingSeparator;
}
org.springframework.web.util.pattern.PathPatternParser
public void setPathOptions(PathContainer.Options pathOptions)
{
    this.pathOptions = pathOptions;
}
 PathPatternRouteMatcher
 implements RouteMatcher
org.springframework.web.util.pattern.PathPatternRouteMatcher
public PathPatternRouteMatcher PathPatternRouteMatcher()
{
    this.parser = new PathPatternParser();
    this.parser.setPathOptions(PathContainer.Options.MESSAGE_ROUTE);
    this.parser.setMatchOptionalTrailingSeparator(false);
}
org.springframework.web.util.pattern.PathPatternRouteMatcher
public PathPatternRouteMatcher PathPatternRouteMatcher(PathPatternParser parser)
{
    Assert.notNull(parser, "PathPatternParser must not be null");
    this.parser = parser;
}
org.springframework.web.util.pattern.PathPatternRouteMatcher
@Override public String combine(String pattern1, String pattern2)
{
    return getPathPattern(pattern1).combine(getPathPattern(pattern2)).getPatternString();
}
org.springframework.web.util.pattern.PathPatternRouteMatcher
@Override public Comparator<String> getPatternComparator(Route route)
{
    return Comparator.comparing(this::getPathPattern);
}
org.springframework.web.util.pattern.PathPatternRouteMatcher
@Override public boolean isPattern(String route)
{
    return getPathPattern(route).hasPatternSyntax();
}
org.springframework.web.util.pattern.PathPatternRouteMatcher
@Override public boolean match(String pattern, Route route)
{
    return getPathPattern(pattern).matches(getPathContainer(route));
}
org.springframework.web.util.pattern.PathPatternRouteMatcher
@Override @Nullable public Map<String, String> matchAndExtract(String pattern, Route route)
{
    PathPattern.PathMatchInfo info = getPathPattern(pattern).matchAndExtract(getPathContainer(route));
    return info != null ? info.getUriVariables() : null;
}
org.springframework.web.util.pattern.PathPatternRouteMatcher
@Override public Route parseRoute(String routeValue)
{
    return new PathContainerRoute(PathContainer.parsePath(routeValue, this.parser.getPathOptions()));
}
 PatternParseException
 extends IllegalArgumentException
PatternMessage
enum values
  • MISSING_CLOSE_CAPTURE
  • MISSING_OPEN_CAPTURE
  • ILLEGAL_NESTED_CAPTURE
  • CANNOT_HAVE_ADJACENT_CAPTURES
  • ILLEGAL_CHARACTER_AT_START_OF_CAPTURE_DESCRIPTOR
  • ILLEGAL_CHARACTER_IN_CAPTURE_DESCRIPTOR
  • NO_MORE_DATA_EXPECTED_AFTER_CAPTURE_THE_REST
  • BADLY_FORMED_CAPTURE_THE_REST
  • MISSING_REGEX_CONSTRAINT
  • ILLEGAL_DOUBLE_CAPTURE
  • REGEX_PATTERN_SYNTAX_EXCEPTION
  • CAPTURE_ALL_IS_STANDALONE_CONSTRUCT
org.springframework.web.util.pattern.PatternParseException
public String formatMessage(Object... inserts)
{
    return MessageFormat.format(this.message, inserts);
}
org.springframework.web.util.pattern.PatternParseException
public Object[] getInserts()
{
    return this.inserts;
}
org.springframework.web.util.pattern.PatternParseException
@Override public String getMessage()
{
    return this.messageType.formatMessage(this.inserts);
}
org.springframework.web.util.pattern.PatternParseException
public PatternMessage getMessageType()
{
    return this.messageType;
}
org.springframework.web.util.pattern.PatternParseException
public int getPosition()
{
    return this.position;
}
org.springframework.web.util.pattern.PatternParseException
public String toDetailedString()
{
    StringBuilder buf = new StringBuilder();
    buf.append(this.pattern).append('\n');
    for (int i = 0; i < this.position; i++) {
        buf.append(' ');
    }
    buf.append("^\n");
    buf.append(getMessage());
    return buf.toString();
}
 RegexPathElement
 extends PathElement
org.springframework.web.util.pattern.RegexPathElement
public Pattern buildPattern(char[] regex, char[] completePattern)
{
    StringBuilder patternBuilder = new StringBuilder();
    String text = new String(regex);
    Matcher matcher = GLOB_PATTERN.matcher(text);
    int end = 0;
    while (matcher.find()) {
        patternBuilder.append(quote(text, end, matcher.start()));
        String match = matcher.group();
        if ("?".equals(match)) {
            patternBuilder.append('.');
        } else if ("*".equals(match)) {
            patternBuilder.append(".*");
            int pos = matcher.start();
            if (pos < 1 || text.charAt(pos - 1) != '.') {
                this.wildcardCount++;
            } 
        } else if (match.startsWith("{") && match.endsWith("}")) {
            int colonIdx = match.indexOf(':');
            if (colonIdx == -1) {
                patternBuilder.append(DEFAULT_VARIABLE_PATTERN);
                String variableName = matcher.group(1);
                if (this.variableNames.contains(variableName)) {
                    throw new PatternParseException(this.pos, completePattern, PatternParseException.PatternMessage.ILLEGAL_DOUBLE_CAPTURE, variableName);
                } 
                this.variableNames.add(variableName);
            } else {
                String variablePattern = match.substring(colonIdx + 1, match.length() - 1);
                patternBuilder.append('(');
                patternBuilder.append(variablePattern);
                patternBuilder.append(')');
                String variableName = match.substring(1, colonIdx);
                if (this.variableNames.contains(variableName)) {
                    throw new PatternParseException(this.pos, completePattern, PatternParseException.PatternMessage.ILLEGAL_DOUBLE_CAPTURE, variableName);
                } 
                this.variableNames.add(variableName);
            }
        } 
        end = matcher.end();
    }
    patternBuilder.append(quote(text, end, text.length()));
    if (this.caseSensitive) {
        return Pattern.compile(patternBuilder.toString());
    } else {
        return Pattern.compile(patternBuilder.toString(), Pattern.CASE_INSENSITIVE);
    }
}
org.springframework.web.util.pattern.RegexPathElement
@Override public int getCaptureCount()
{
    return this.variableNames.size();
}
org.springframework.web.util.pattern.RegexPathElement
@Override public char[] getChars()
{
    return this.regex;
}
org.springframework.web.util.pattern.RegexPathElement
@Override public int getNormalizedLength()
{
    int varsLength = 0;
    for (String variableName: this.variableNames) {
        varsLength += variableName.length();
    }
    return (this.regex.length - varsLength - this.variableNames.size());
}
org.springframework.web.util.pattern.RegexPathElement
@Override public int getScore()
{
    return (getCaptureCount() * CAPTURE_VARIABLE_WEIGHT + getWildcardCount() * WILDCARD_WEIGHT);
}
org.springframework.web.util.pattern.RegexPathElement
public List<String> getVariableNames()
{
    return this.variableNames;
}
org.springframework.web.util.pattern.RegexPathElement
@Override public int getWildcardCount()
{
    return this.wildcardCount;
}
org.springframework.web.util.pattern.RegexPathElement
@Override public boolean matches(int pathIndex, MatchingContext matchingContext)
{
    String textToMatch = matchingContext.pathElementValue(pathIndex);
    Matcher matcher = this.pattern.matcher(textToMatch);
    boolean matches = matcher.matches();
    if (matches) {
        if (isNoMorePattern()) {
            if (matchingContext.determineRemainingPath && (this.variableNames.isEmpty() ? true : textToMatch.length() > 0)) {
                matchingContext.remainingPathIndex = pathIndex + 1;
                matches = true;
            } else {
                matches = (pathIndex + 1) >= matchingContext.pathLength && (this.variableNames.isEmpty() || textToMatch.length() > 0);
                if (!matches && matchingContext.isMatchOptionalTrailingSeparator()) {
                    matches = (this.variableNames.isEmpty() || textToMatch.length() > 0) && (pathIndex + 2) >= matchingContext.pathLength && matchingContext.isSeparator(pathIndex + 1);
                } 
            }
        } else {
            matches = (this.next != null && this.next.matches(pathIndex + 1, matchingContext));
        }
    } 
    if (matches && matchingContext.extractingVariables) {
        if (this.variableNames.size() != matcher.groupCount()) {
            throw new IllegalArgumentException("The number of capturing groups in the pattern segment " + this.pattern + " does not match the number of URI template variables it defines, " + "which can occur if capturing groups are used in a URI template regex. " + "Use non-capturing groups instead.");
        } 
        for (int i = 1; i <= matcher.groupCount(); i++) {
            String name = this.variableNames.get(i - 1);
            String value = matcher.group(i);
            matchingContext.set(name, value, (i == this.variableNames.size()) ? ((PathSegment)matchingContext.pathElements.get(pathIndex)).parameters() : NO_PARAMETERS);
        }
    } 
    return matches;
}
org.springframework.web.util.pattern.RegexPathElement
@Override public String toString()
{
    return "Regex(" + String.valueOf(this.regex) + ")";
}
 SeparatorPathElement
 extends PathElement
org.springframework.web.util.pattern.SeparatorPathElement
@Override public char[] getChars()
{
    return new char[]{this.separator};
}
org.springframework.web.util.pattern.SeparatorPathElement
@Override public int getNormalizedLength()
{
    return 1;
}
org.springframework.web.util.pattern.SeparatorPathElement
@Override public String toString()
{
    return "Separator(" + this.separator + ")";
}
 SingleCharWildcardedPathElement
 extends PathElement
org.springframework.web.util.pattern.SingleCharWildcardedPathElement
public SingleCharWildcardedPathElement SingleCharWildcardedPathElement(int pos, char[] literalText, int questionMarkCount, boolean caseSensitive, char separator)
{
    super(pos, separator);
    this.len = literalText.length;
    this.questionMarkCount = questionMarkCount;
    this.caseSensitive = caseSensitive;
    if (caseSensitive) {
        this.text = literalText;
    } else {
        this.text = new char[literalText.length];
        for (int i = 0; i < this.len; i++) {
            this.text[i] = Character.toLowerCase(literalText[i]);
        }
    }
}
org.springframework.web.util.pattern.SingleCharWildcardedPathElement
@Override public char[] getChars()
{
    return this.text;
}
org.springframework.web.util.pattern.SingleCharWildcardedPathElement
@Override public int getNormalizedLength()
{
    return this.len;
}
org.springframework.web.util.pattern.SingleCharWildcardedPathElement
@Override public int getWildcardCount()
{
    return this.questionMarkCount;
}
org.springframework.web.util.pattern.SingleCharWildcardedPathElement
@Override public String toString()
{
    return "SingleCharWildcarded(" + String.valueOf(this.text) + ")";
}
 SubSequence
 implements CharSequence
org.springframework.web.util.pattern.SubSequence
@Override public char charAt(int index)
{
    return this.chars[this.start + index];
}
org.springframework.web.util.pattern.SubSequence
@Override public int length()
{
    return (this.end - this.start);
}
org.springframework.web.util.pattern.SubSequence
@Override public CharSequence subSequence(int start, int end)
{
    return new SubSequence(this.chars, this.start + start, this.start + end);
}
org.springframework.web.util.pattern.SubSequence
@Override public String toString()
{
    return new String(this.chars, this.start, this.end - this.start);
}
 WildcardPathElement
 extends PathElement
org.springframework.web.util.pattern.WildcardPathElement
public WildcardPathElement WildcardPathElement(int pos, char separator)
{
    super(pos, separator);
}
org.springframework.web.util.pattern.WildcardPathElement
@Override public char[] getChars()
{
    return new char[]{'*'};
}
org.springframework.web.util.pattern.WildcardPathElement
@Override public int getNormalizedLength()
{
    return 1;
}
org.springframework.web.util.pattern.WildcardPathElement
@Override public int getScore()
{
    return WILDCARD_WEIGHT;
}
org.springframework.web.util.pattern.WildcardPathElement
@Override public int getWildcardCount()
{
    return 1;
}
org.springframework.web.util.pattern.WildcardPathElement
@Override public String toString()
{
    return "Wildcard(*)";
}
 WildcardTheRestPathElement
 extends PathElement
org.springframework.web.util.pattern.WildcardTheRestPathElement
@Override public char[] getChars()
{
    return (this.separator + "**").toCharArray();
}
org.springframework.web.util.pattern.WildcardTheRestPathElement
@Override public int getNormalizedLength()
{
    return 1;
}
org.springframework.web.util.pattern.WildcardTheRestPathElement
@Override public int getWildcardCount()
{
    return 1;
}
org.springframework.web.util.pattern.WildcardTheRestPathElement
@Override public boolean matches(int pathIndex, PathPattern.MatchingContext matchingContext)
{
    if (pathIndex < matchingContext.pathLength && !matchingContext.isSeparator(pathIndex)) {
        return false;
    } 
    if (matchingContext.determineRemainingPath) {
        matchingContext.remainingPathIndex = matchingContext.pathLength;
    } 
    return true;
}
org.springframework.web.util.pattern.WildcardTheRestPathElement
@Override public String toString()
{
    return "WildcardTheRest(" + this.separator + "**)";
}